diff --git a/.gitignore b/.gitignore
index bbd9216c..44173f41 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,11 @@ yarn-debug.log*
yarn-error.log*
lerna-debug.log*
+*.winmd
+*.dll
+*.pri
+*.exe
+
# Diagnostic reports (https://nodejs.org/api/report.html)
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
@@ -44,6 +49,9 @@ jspm_packages/
# Snowpack dependency directory (https://snowpack.dev/)
web_modules/
+B3B9BB81.56264F78B4FFF/
+zeptolabuklimited.cuttherope/
+
# TypeScript cache
*.tsbuildinfo
diff --git a/.vscode/launch.json b/.vscode/launch.json
index ef3f9b3e..9d8aa949 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -10,7 +10,7 @@
"windows": {
"runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron.cmd"
},
- "args" : ["."],
+ "args" : [".", "winstore/Windows.Store"],
"outputCapture": "std"
}
]
diff --git a/gen/Windows.ts b/gen/Windows.ts
new file mode 100644
index 00000000..52e77bf4
--- /dev/null
+++ b/gen/Windows.ts
@@ -0,0 +1,223828 @@
+// ----------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+//
+// Generated from Windows.winmd version 255.255.255.255 at 26/03/2021 19:04:13
+//
+// ----------------------------------------------------------------------------------
+export namespace Windows {
+ export namespace AI {
+ export namespace MachineLearning {
+ export interface ILearningModelFeatureDescriptor {
+ description: string;
+ isRequired: Boolean;
+ kind: LearningModelFeatureKind;
+ name: string;
+ }
+ export interface ILearningModelFeatureValue {
+ kind: LearningModelFeatureKind;
+ }
+ export interface ILearningModelOperatorProvider {
+ }
+ export class ImageFeatureDescriptor implements IImageFeatureDescriptor, ILearningModelFeatureDescriptor {
+ bitmapAlphaMode: Graphics.Imaging.BitmapAlphaMode;
+ bitmapPixelFormat: Graphics.Imaging.BitmapPixelFormat;
+ height: number;
+ width: number;
+ description: string;
+ isRequired: Boolean;
+ kind: LearningModelFeatureKind;
+ name: string;
+
+ }
+ export class ImageFeatureValue implements IImageFeatureValue, ILearningModelFeatureValue {
+ videoFrame: Media.VideoFrame;
+ kind: LearningModelFeatureKind;
+
+ static createFromVideoFrame(image: Media.VideoFrame): ImageFeatureValue {
+ throw new Error('shimmed function ImageFeatureValue.createFromVideoFrame');
+ }
+
+ }
+ export interface ITensor extends ILearningModelFeatureValue {
+ shape: number[];
+ tensorKind: TensorKind;
+ }
+ export class LearningModel implements ILearningModel, Foundation.IClosable {
+ author: string;
+ description: string;
+ domain: string;
+ inputFeatures: ILearningModelFeatureDescriptor[];
+ metadata: string[];
+ name: string;
+ outputFeatures: ILearningModelFeatureDescriptor[];
+ version: number;
+
+ close(): void {
+ console.warn('shimmed function LearningModel.close');
+ }
+
+ static loadFromStorageFileAsync(modelFile: Storage.IStorageFile): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModel.loadFromStorageFileAsync');
+ }
+
+ static loadFromStreamAsync(modelStream: Storage.Streams.IRandomAccessStreamReference): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModel.loadFromStreamAsync');
+ }
+
+ static loadFromFilePath(filePath: string): LearningModel {
+ throw new Error('shimmed function LearningModel.loadFromFilePath');
+ }
+
+ static loadFromStream(modelStream: Storage.Streams.IRandomAccessStreamReference): LearningModel {
+ throw new Error('shimmed function LearningModel.loadFromStream');
+ }
+
+ static loadFromStorageFileAsync_1(modelFile: Storage.IStorageFile, operatorProvider: ILearningModelOperatorProvider): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModel.loadFromStorageFileAsync_1');
+ }
+
+ static loadFromStreamAsync_1(modelStream: Storage.Streams.IRandomAccessStreamReference, operatorProvider: ILearningModelOperatorProvider): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModel.loadFromStreamAsync_1');
+ }
+
+ static loadFromFilePath_1(filePath: string, operatorProvider: ILearningModelOperatorProvider): LearningModel {
+ throw new Error('shimmed function LearningModel.loadFromFilePath_1');
+ }
+
+ static loadFromStream_1(modelStream: Storage.Streams.IRandomAccessStreamReference, operatorProvider: ILearningModelOperatorProvider): LearningModel {
+ throw new Error('shimmed function LearningModel.loadFromStream_1');
+ }
+
+ }
+ export class LearningModelBinding implements ILearningModelBinding, Foundation.Collections.IMapView, Foundation.Collections.IIterable> {
+ // constructor(session: LearningModelSession);
+ constructor(session: LearningModelSession) {}
+
+ size: number;
+
+ bind(name: string, value: any): void {
+ console.warn('shimmed function LearningModelBinding.bind');
+ }
+
+ bind_1(name: string, value: any, props: Foundation.Collections.IPropertySet): void {
+ console.warn('shimmed function LearningModelBinding.bind_1');
+ }
+
+ clear(): void {
+ console.warn('shimmed function LearningModelBinding.clear');
+ }
+
+ lookup(key: string): any {
+ throw new Error('shimmed function LearningModelBinding.lookup');
+ }
+
+ hasKey(key: string): Boolean {
+ throw new Error('shimmed function LearningModelBinding.hasKey');
+ }
+
+ split(): { first: string[], second: string[] } {
+ throw new Error('shimmed function LearningModelBinding.split');
+ }
+
+ first(): Foundation.Collections.IIterator> {
+ throw new Error('shimmed function LearningModelBinding.first');
+ }
+
+ }
+ export class LearningModelDevice implements ILearningModelDevice {
+ // constructor(deviceKind: LearningModelDeviceKind);
+ constructor(deviceKind: LearningModelDeviceKind) {}
+
+ adapterId: Graphics.DisplayAdapterId;
+ direct3D11Device: Graphics.DirectX.Direct3D11.IDirect3DDevice;
+
+ static createFromDirect3D11Device(device: Graphics.DirectX.Direct3D11.IDirect3DDevice): LearningModelDevice {
+ throw new Error('shimmed function LearningModelDevice.createFromDirect3D11Device');
+ }
+
+ }
+ export enum LearningModelDeviceKind {
+ default,
+ cpu,
+ directX,
+ directXHighPerformance,
+ directXMinPower,
+ }
+ export class LearningModelEvaluationResult implements ILearningModelEvaluationResult {
+ correlationId: string;
+ errorStatus: number;
+ outputs: string[];
+ succeeded: Boolean;
+
+ }
+ export enum LearningModelFeatureKind {
+ tensor,
+ sequence,
+ map,
+ image,
+ }
+ export class LearningModelSession implements ILearningModelSession, Foundation.IClosable {
+ // constructor(model: LearningModel, deviceToRunOn: LearningModelDevice, learningModelSessionOptions: LearningModelSessionOptions);
+ // constructor(model: LearningModel);
+ // constructor(model: LearningModel, deviceToRunOn: LearningModelDevice);
+ constructor(model: LearningModel, deviceToRunOn: LearningModelDevice, learningModelSessionOptions: LearningModelSessionOptions) {}
+
+ device: LearningModelDevice;
+ evaluationProperties: Foundation.Collections.IPropertySet;
+ model: LearningModel;
+
+ evaluateAsync(bindings: LearningModelBinding, correlationId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModelSession.evaluateAsync');
+ }
+
+ evaluateFeaturesAsync(features: string[], correlationId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModelSession.evaluateFeaturesAsync');
+ }
+
+ evaluate(bindings: LearningModelBinding, correlationId: string): LearningModelEvaluationResult {
+ throw new Error('shimmed function LearningModelSession.evaluate');
+ }
+
+ evaluateFeatures(features: string[], correlationId: string): LearningModelEvaluationResult {
+ throw new Error('shimmed function LearningModelSession.evaluateFeatures');
+ }
+
+ close(): void {
+ console.warn('shimmed function LearningModelSession.close');
+ }
+
+ }
+ export class LearningModelSessionOptions implements ILearningModelSessionOptions {
+ // constructor();
+ batchSizeOverride: number = 1;
+
+ }
+ export interface MachineLearningContract {
+ }
+ export class MapFeatureDescriptor implements IMapFeatureDescriptor, ILearningModelFeatureDescriptor {
+ description: string;
+ isRequired: Boolean;
+ kind: LearningModelFeatureKind;
+ name: string;
+ keyKind: TensorKind;
+ valueDescriptor: ILearningModelFeatureDescriptor;
+
+ }
+ export namespace Preview {
+ export enum FeatureElementKindPreview {
+ undefined,
+ float,
+ uint8,
+ int8,
+ uint16,
+ int16,
+ int32,
+ int64,
+ string,
+ boolean,
+ float16,
+ double,
+ uint32,
+ uint64,
+ complex64,
+ complex128,
+ }
+ export interface ILearningModelVariableDescriptorPreview {
+ description: string;
+ isRequired: Boolean;
+ modelFeatureKind: LearningModelFeatureKindPreview;
+ name: string;
+ }
+ export class ImageVariableDescriptorPreview implements IImageVariableDescriptorPreview, ILearningModelVariableDescriptorPreview {
+ bitmapPixelFormat: Graphics.Imaging.BitmapPixelFormat;
+ height: number;
+ width: number;
+ description: string;
+ isRequired: Boolean;
+ modelFeatureKind: LearningModelFeatureKindPreview;
+ name: string;
+
+ }
+ export class InferencingOptionsPreview implements IInferencingOptionsPreview {
+ reclaimMemoryAfterEvaluation: Boolean;
+ preferredDeviceKind: LearningModelDeviceKindPreview;
+ minimizeMemoryAllocation: Boolean;
+ maxBatchSize: number;
+ isTracingEnabled: Boolean;
+
+ }
+ export class LearningModelBindingPreview implements ILearningModelBindingPreview, Foundation.Collections.IMapView, Foundation.Collections.IIterable> {
+ // constructor(model: LearningModelPreview);
+ constructor(model: LearningModelPreview) {}
+
+ size: number;
+
+ bind(name: string, value: any): void {
+ console.warn('shimmed function LearningModelBindingPreview.bind');
+ }
+
+ bind_1(name: string, value: any, metadata: Foundation.Collections.IPropertySet): void {
+ console.warn('shimmed function LearningModelBindingPreview.bind_1');
+ }
+
+ clear(): void {
+ console.warn('shimmed function LearningModelBindingPreview.clear');
+ }
+
+ lookup(key: string): any {
+ throw new Error('shimmed function LearningModelBindingPreview.lookup');
+ }
+
+ hasKey(key: string): Boolean {
+ throw new Error('shimmed function LearningModelBindingPreview.hasKey');
+ }
+
+ split(): { first: string[], second: string[] } {
+ throw new Error('shimmed function LearningModelBindingPreview.split');
+ }
+
+ first(): Foundation.Collections.IIterator> {
+ throw new Error('shimmed function LearningModelBindingPreview.first');
+ }
+
+ }
+ export class LearningModelDescriptionPreview implements ILearningModelDescriptionPreview {
+ author: string;
+ description: string;
+ domain: string;
+ inputFeatures: Foundation.Collections.IIterable;
+ metadata: string[];
+ name: string;
+ outputFeatures: Foundation.Collections.IIterable;
+ version: number;
+
+ }
+ export enum LearningModelDeviceKindPreview {
+ learningDeviceAny,
+ learningDeviceCpu,
+ learningDeviceGpu,
+ learningDeviceNpu,
+ learningDeviceDsp,
+ learningDeviceFpga,
+ }
+ export class LearningModelEvaluationResultPreview implements ILearningModelEvaluationResultPreview {
+ correlationId: string;
+ outputs: string[];
+
+ }
+ export enum LearningModelFeatureKindPreview {
+ undefined,
+ tensor,
+ sequence,
+ map,
+ image,
+ }
+ export class LearningModelPreview implements ILearningModelPreview {
+ inferencingOptions: InferencingOptionsPreview;
+ description: LearningModelDescriptionPreview;
+
+ evaluateAsync(binding: LearningModelBindingPreview, correlationId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModelPreview.evaluateAsync');
+ }
+
+ evaluateFeaturesAsync(features: string[], correlationId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModelPreview.evaluateFeaturesAsync');
+ }
+
+ static loadModelFromStorageFileAsync(modelFile: Storage.IStorageFile): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModelPreview.loadModelFromStorageFileAsync');
+ }
+
+ static loadModelFromStreamAsync(modelStream: Storage.Streams.IRandomAccessStreamReference): Foundation.IAsyncOperation {
+ throw new Error('shimmed function LearningModelPreview.loadModelFromStreamAsync');
+ }
+
+ }
+ export class LearningModelVariableDescriptorPreview implements ILearningModelVariableDescriptorPreview {
+ description: string;
+ isRequired: Boolean;
+ modelFeatureKind: LearningModelFeatureKindPreview;
+ name: string;
+
+ }
+ export interface MachineLearningPreviewContract {
+ }
+ export class MapVariableDescriptorPreview implements IMapVariableDescriptorPreview, ILearningModelVariableDescriptorPreview {
+ description: string;
+ isRequired: Boolean;
+ modelFeatureKind: LearningModelFeatureKindPreview;
+ name: string;
+ fields: ILearningModelVariableDescriptorPreview;
+ keyKind: FeatureElementKindPreview;
+ validIntegerKeys: Foundation.Collections.IIterable;
+ validStringKeys: Foundation.Collections.IIterable;
+
+ }
+ export class SequenceVariableDescriptorPreview implements ISequenceVariableDescriptorPreview, ILearningModelVariableDescriptorPreview {
+ description: string;
+ isRequired: Boolean;
+ modelFeatureKind: LearningModelFeatureKindPreview;
+ name: string;
+ elementType: ILearningModelVariableDescriptorPreview;
+
+ }
+ export class TensorVariableDescriptorPreview implements ITensorVariableDescriptorPreview, ILearningModelVariableDescriptorPreview {
+ description: string;
+ isRequired: Boolean;
+ modelFeatureKind: LearningModelFeatureKindPreview;
+ name: string;
+ dataType: FeatureElementKindPreview;
+ shape: Foundation.Collections.IIterable;
+
+ }
+ }
+ export class SequenceFeatureDescriptor implements ISequenceFeatureDescriptor, ILearningModelFeatureDescriptor {
+ description: string;
+ isRequired: Boolean;
+ kind: LearningModelFeatureKind;
+ name: string;
+ elementDescriptor: ILearningModelFeatureDescriptor;
+
+ }
+ export class TensorBoolean implements ITensorBoolean, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): Boolean[] {
+ throw new Error('shimmed function TensorBoolean.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorBoolean.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorBoolean.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: Boolean[]): TensorBoolean {
+ throw new Error('shimmed function TensorBoolean.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorBoolean {
+ throw new Error('shimmed function TensorBoolean.createFromBuffer');
+ }
+
+ static create(): TensorBoolean {
+ throw new Error('shimmed function TensorBoolean.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorBoolean {
+ throw new Error('shimmed function TensorBoolean.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: Boolean[]): TensorBoolean {
+ throw new Error('shimmed function TensorBoolean.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorBoolean {
+ throw new Error('shimmed function TensorBoolean.createFromIterable');
+ }
+
+ }
+ export class TensorDouble implements ITensorDouble, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorDouble.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorDouble.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorDouble.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorDouble {
+ throw new Error('shimmed function TensorDouble.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorDouble {
+ throw new Error('shimmed function TensorDouble.createFromBuffer');
+ }
+
+ static create(): TensorDouble {
+ throw new Error('shimmed function TensorDouble.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorDouble {
+ throw new Error('shimmed function TensorDouble.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorDouble {
+ throw new Error('shimmed function TensorDouble.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorDouble {
+ throw new Error('shimmed function TensorDouble.createFromIterable');
+ }
+
+ }
+ export class TensorFeatureDescriptor implements ITensorFeatureDescriptor, ILearningModelFeatureDescriptor {
+ description: string;
+ isRequired: Boolean;
+ kind: LearningModelFeatureKind;
+ name: string;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ }
+ export class TensorFloat implements ITensorFloat, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorFloat.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorFloat.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorFloat.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorFloat {
+ throw new Error('shimmed function TensorFloat.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorFloat {
+ throw new Error('shimmed function TensorFloat.createFromBuffer');
+ }
+
+ static create(): TensorFloat {
+ throw new Error('shimmed function TensorFloat.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorFloat {
+ throw new Error('shimmed function TensorFloat.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorFloat {
+ throw new Error('shimmed function TensorFloat.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorFloat {
+ throw new Error('shimmed function TensorFloat.createFromIterable');
+ }
+
+ }
+ export class TensorFloat16Bit implements ITensorFloat16Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorFloat16Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorFloat16Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorFloat16Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorFloat16Bit {
+ throw new Error('shimmed function TensorFloat16Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorFloat16Bit {
+ throw new Error('shimmed function TensorFloat16Bit.createFromBuffer');
+ }
+
+ static create(): TensorFloat16Bit {
+ throw new Error('shimmed function TensorFloat16Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorFloat16Bit {
+ throw new Error('shimmed function TensorFloat16Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorFloat16Bit {
+ throw new Error('shimmed function TensorFloat16Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorFloat16Bit {
+ throw new Error('shimmed function TensorFloat16Bit.createFromIterable');
+ }
+
+ }
+ export class TensorInt16Bit implements ITensorInt16Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorInt16Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorInt16Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorInt16Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorInt16Bit {
+ throw new Error('shimmed function TensorInt16Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorInt16Bit {
+ throw new Error('shimmed function TensorInt16Bit.createFromBuffer');
+ }
+
+ static create(): TensorInt16Bit {
+ throw new Error('shimmed function TensorInt16Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorInt16Bit {
+ throw new Error('shimmed function TensorInt16Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorInt16Bit {
+ throw new Error('shimmed function TensorInt16Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorInt16Bit {
+ throw new Error('shimmed function TensorInt16Bit.createFromIterable');
+ }
+
+ }
+ export class TensorInt32Bit implements ITensorInt32Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorInt32Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorInt32Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorInt32Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorInt32Bit {
+ throw new Error('shimmed function TensorInt32Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorInt32Bit {
+ throw new Error('shimmed function TensorInt32Bit.createFromBuffer');
+ }
+
+ static create(): TensorInt32Bit {
+ throw new Error('shimmed function TensorInt32Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorInt32Bit {
+ throw new Error('shimmed function TensorInt32Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorInt32Bit {
+ throw new Error('shimmed function TensorInt32Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorInt32Bit {
+ throw new Error('shimmed function TensorInt32Bit.createFromIterable');
+ }
+
+ }
+ export class TensorInt64Bit implements ITensorInt64Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorInt64Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorInt64Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorInt64Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorInt64Bit {
+ throw new Error('shimmed function TensorInt64Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorInt64Bit {
+ throw new Error('shimmed function TensorInt64Bit.createFromBuffer');
+ }
+
+ static create(): TensorInt64Bit {
+ throw new Error('shimmed function TensorInt64Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorInt64Bit {
+ throw new Error('shimmed function TensorInt64Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorInt64Bit {
+ throw new Error('shimmed function TensorInt64Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorInt64Bit {
+ throw new Error('shimmed function TensorInt64Bit.createFromIterable');
+ }
+
+ }
+ export class TensorInt8Bit implements ITensorInt8Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorInt8Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorInt8Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorInt8Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorInt8Bit {
+ throw new Error('shimmed function TensorInt8Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorInt8Bit {
+ throw new Error('shimmed function TensorInt8Bit.createFromBuffer');
+ }
+
+ static create(): TensorInt8Bit {
+ throw new Error('shimmed function TensorInt8Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorInt8Bit {
+ throw new Error('shimmed function TensorInt8Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorInt8Bit {
+ throw new Error('shimmed function TensorInt8Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorInt8Bit {
+ throw new Error('shimmed function TensorInt8Bit.createFromIterable');
+ }
+
+ }
+ export enum TensorKind {
+ undefined,
+ float,
+ uint8,
+ int8,
+ uint16,
+ int16,
+ int32,
+ int64,
+ string,
+ boolean,
+ float16,
+ double,
+ uint32,
+ uint64,
+ complex64,
+ complex128,
+ }
+ export class TensorString implements ITensorString, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): string[] {
+ throw new Error('shimmed function TensorString.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorString.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorString.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: string[]): TensorString {
+ throw new Error('shimmed function TensorString.createFromShapeArrayAndDataArray');
+ }
+
+ static create(): TensorString {
+ throw new Error('shimmed function TensorString.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorString {
+ throw new Error('shimmed function TensorString.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: string[]): TensorString {
+ throw new Error('shimmed function TensorString.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorString {
+ throw new Error('shimmed function TensorString.createFromIterable');
+ }
+
+ }
+ export class TensorUInt16Bit implements ITensorUInt16Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorUInt16Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorUInt16Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorUInt16Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorUInt16Bit {
+ throw new Error('shimmed function TensorUInt16Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorUInt16Bit {
+ throw new Error('shimmed function TensorUInt16Bit.createFromBuffer');
+ }
+
+ static create(): TensorUInt16Bit {
+ throw new Error('shimmed function TensorUInt16Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorUInt16Bit {
+ throw new Error('shimmed function TensorUInt16Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorUInt16Bit {
+ throw new Error('shimmed function TensorUInt16Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorUInt16Bit {
+ throw new Error('shimmed function TensorUInt16Bit.createFromIterable');
+ }
+
+ }
+ export class TensorUInt32Bit implements ITensorUInt32Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorUInt32Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorUInt32Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorUInt32Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorUInt32Bit {
+ throw new Error('shimmed function TensorUInt32Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorUInt32Bit {
+ throw new Error('shimmed function TensorUInt32Bit.createFromBuffer');
+ }
+
+ static create(): TensorUInt32Bit {
+ throw new Error('shimmed function TensorUInt32Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorUInt32Bit {
+ throw new Error('shimmed function TensorUInt32Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorUInt32Bit {
+ throw new Error('shimmed function TensorUInt32Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorUInt32Bit {
+ throw new Error('shimmed function TensorUInt32Bit.createFromIterable');
+ }
+
+ }
+ export class TensorUInt64Bit implements ITensorUInt64Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorUInt64Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorUInt64Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorUInt64Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorUInt64Bit {
+ throw new Error('shimmed function TensorUInt64Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorUInt64Bit {
+ throw new Error('shimmed function TensorUInt64Bit.createFromBuffer');
+ }
+
+ static create(): TensorUInt64Bit {
+ throw new Error('shimmed function TensorUInt64Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorUInt64Bit {
+ throw new Error('shimmed function TensorUInt64Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorUInt64Bit {
+ throw new Error('shimmed function TensorUInt64Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorUInt64Bit {
+ throw new Error('shimmed function TensorUInt64Bit.createFromIterable');
+ }
+
+ }
+ export class TensorUInt8Bit implements ITensorUInt8Bit, ITensor, ILearningModelFeatureValue, Foundation.IMemoryBuffer, Foundation.IClosable {
+ kind: LearningModelFeatureKind;
+ shape: number[];
+ tensorKind: TensorKind;
+
+ getAsVectorView(): number[] {
+ throw new Error('shimmed function TensorUInt8Bit.getAsVectorView');
+ }
+
+ createReference(): Foundation.IMemoryBufferReference {
+ throw new Error('shimmed function TensorUInt8Bit.createReference');
+ }
+
+ close(): void {
+ console.warn('shimmed function TensorUInt8Bit.close');
+ }
+
+ static createFromShapeArrayAndDataArray(shape: number[], data: number[]): TensorUInt8Bit {
+ throw new Error('shimmed function TensorUInt8Bit.createFromShapeArrayAndDataArray');
+ }
+
+ static createFromBuffer(shape: number[], buffer: Storage.Streams.IBuffer): TensorUInt8Bit {
+ throw new Error('shimmed function TensorUInt8Bit.createFromBuffer');
+ }
+
+ static create(): TensorUInt8Bit {
+ throw new Error('shimmed function TensorUInt8Bit.create');
+ }
+
+ static create_1(shape: Foundation.Collections.IIterable): TensorUInt8Bit {
+ throw new Error('shimmed function TensorUInt8Bit.create_1');
+ }
+
+ static createFromArray(shape: Foundation.Collections.IIterable, data: number[]): TensorUInt8Bit {
+ throw new Error('shimmed function TensorUInt8Bit.createFromArray');
+ }
+
+ static createFromIterable(shape: Foundation.Collections.IIterable, data: Foundation.Collections.IIterable): TensorUInt8Bit {
+ throw new Error('shimmed function TensorUInt8Bit.createFromIterable');
+ }
+
+ }
+ }
+ }
+ export namespace ApplicationModel {
+ export namespace Activation {
+ export interface ActivatedEventsContract {
+ }
+ export interface ActivationCameraSettingsContract {
+ }
+ export enum ActivationKind {
+ launch,
+ search,
+ shareTarget,
+ file,
+ protocol,
+ fileOpenPicker,
+ fileSavePicker,
+ cachedFileUpdater,
+ contactPicker,
+ device,
+ printTaskSettings,
+ cameraSettings,
+ restrictedLaunch,
+ appointmentsProvider,
+ contact,
+ lockScreenCall,
+ voiceCommand,
+ lockScreen,
+ pickerReturned = 1000,
+ walletAction,
+ pickFileContinuation,
+ pickSaveFileContinuation,
+ pickFolderContinuation,
+ webAuthenticationBrokerContinuation,
+ webAccountProvider,
+ componentUI,
+ protocolForResults = 1009,
+ toastNotification,
+ print3DWorkflow,
+ dialReceiver,
+ devicePairing,
+ userDataAccountsProvider,
+ filePickerExperience,
+ lockScreenComponent,
+ contactPanel,
+ printWorkflowForegroundTask,
+ gameUIProvider,
+ startupTask,
+ commandLineLaunch,
+ barcodeScannerProvider,
+ }
+ export enum ApplicationExecutionState {
+ notRunning,
+ running,
+ suspended,
+ terminated,
+ closedByUser,
+ }
+ export class AppointmentsProviderAddAppointmentActivatedEventArgs implements IAppointmentsProviderAddAppointmentActivatedEventArgs, IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ verb: string;
+ addAppointmentOperation: Appointments.AppointmentsProvider.AddAppointmentOperation;
+
+ }
+ export class AppointmentsProviderRemoveAppointmentActivatedEventArgs implements IAppointmentsProviderRemoveAppointmentActivatedEventArgs, IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ verb: string;
+ removeAppointmentOperation: Appointments.AppointmentsProvider.RemoveAppointmentOperation;
+
+ }
+ export class AppointmentsProviderReplaceAppointmentActivatedEventArgs implements IAppointmentsProviderReplaceAppointmentActivatedEventArgs, IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ verb: string;
+ replaceAppointmentOperation: Appointments.AppointmentsProvider.ReplaceAppointmentOperation;
+
+ }
+ export class AppointmentsProviderShowAppointmentDetailsActivatedEventArgs implements IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs, IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ verb: string;
+ instanceStartDate: Date | null;
+ localId: string;
+ roamingId: string;
+
+ }
+ export class AppointmentsProviderShowTimeFrameActivatedEventArgs implements IAppointmentsProviderShowTimeFrameActivatedEventArgs, IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ verb: string;
+ duration: number;
+ timeToShow: Date;
+
+ }
+ export class BackgroundActivatedEventArgs implements IBackgroundActivatedEventArgs {
+ taskInstance: Background.IBackgroundTaskInstance;
+
+ }
+ export class BarcodeScannerPreviewActivatedEventArgs implements IBarcodeScannerPreviewActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ connectionId: string;
+
+ }
+ export class CachedFileUpdaterActivatedEventArgs implements ICachedFileUpdaterActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ cachedFileUpdaterUI: Storage.Provider.CachedFileUpdaterUI;
+
+ }
+ export class CameraSettingsActivatedEventArgs implements ICameraSettingsActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ videoDeviceController: any;
+ videoDeviceExtension: any;
+
+ }
+ export class CommandLineActivatedEventArgs implements ICommandLineActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ operation: CommandLineActivationOperation;
+
+ }
+ export class CommandLineActivationOperation implements ICommandLineActivationOperation {
+ exitCode: number;
+ __arguments: string;
+ currentDirectoryPath: string;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function CommandLineActivationOperation.getDeferral');
+ }
+
+ }
+ export interface ContactActivatedEventsContract {
+ }
+ export class ContactCallActivatedEventArgs implements IContactCallActivatedEventArgs, IContactActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ verb: string;
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+
+ }
+ export class ContactMapActivatedEventArgs implements IContactMapActivatedEventArgs, IContactActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ verb: string;
+ address: Contacts.ContactAddress;
+ contact: Contacts.Contact;
+
+ }
+ export class ContactMessageActivatedEventArgs implements IContactMessageActivatedEventArgs, IContactActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ verb: string;
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+
+ }
+ export class ContactPanelActivatedEventArgs implements IContactPanelActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ contact: Contacts.Contact;
+ contactPanel: Contacts.ContactPanel;
+
+ }
+ export class ContactPickerActivatedEventArgs implements IContactPickerActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ contactPickerUI: Contacts.Provider.ContactPickerUI;
+
+ }
+ export class ContactPostActivatedEventArgs implements IContactPostActivatedEventArgs, IContactActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ verb: string;
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+
+ }
+ export class ContactVideoCallActivatedEventArgs implements IContactVideoCallActivatedEventArgs, IContactActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ verb: string;
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+
+ }
+ export class DeviceActivatedEventArgs implements IDeviceActivatedEventArgs, IActivatedEventArgs, IApplicationViewActivatedEventArgs, IViewSwitcherProvider, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ deviceInformationId: string;
+ verb: string;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class DevicePairingActivatedEventArgs implements IDevicePairingActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ deviceInformation: Devices.Enumeration.DeviceInformation;
+
+ }
+ export class DialReceiverActivatedEventArgs implements IDialReceiverActivatedEventArgs, ILaunchActivatedEventArgs, IActivatedEventArgs, IApplicationViewActivatedEventArgs, IViewSwitcherProvider, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ appName: string;
+ __arguments: string;
+ tileId: string;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class FileActivatedEventArgs implements IFileActivatedEventArgs, IActivatedEventArgs, IFileActivatedEventArgsWithNeighboringFiles, IFileActivatedEventArgsWithCallerPackageFamilyName, IApplicationViewActivatedEventArgs, IViewSwitcherProvider, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ files: Storage.IStorageItem[];
+ verb: string;
+ callerPackageFamilyName: string;
+ neighboringFilesQuery: Storage.Search.StorageFileQueryResult;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class FileOpenPickerActivatedEventArgs implements IFileOpenPickerActivatedEventArgs, IActivatedEventArgs, IFileOpenPickerActivatedEventArgs2, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ fileOpenPickerUI: Storage.Pickers.Provider.FileOpenPickerUI;
+ callerPackageFamilyName: string;
+
+ }
+ export class FileOpenPickerContinuationEventArgs implements IFileOpenPickerContinuationEventArgs, IContinuationActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ continuationData: Foundation.Collections.ValueSet;
+ files: Storage.StorageFile[];
+
+ }
+ export class FileSavePickerActivatedEventArgs implements IFileSavePickerActivatedEventArgs, IActivatedEventArgs, IFileSavePickerActivatedEventArgs2, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ fileSavePickerUI: Storage.Pickers.Provider.FileSavePickerUI;
+ callerPackageFamilyName: string;
+ enterpriseId: string;
+
+ }
+ export class FileSavePickerContinuationEventArgs implements IFileSavePickerContinuationEventArgs, IContinuationActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ continuationData: Foundation.Collections.ValueSet;
+ file: Storage.StorageFile;
+
+ }
+ export class FolderPickerContinuationEventArgs implements IFolderPickerContinuationEventArgs, IContinuationActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ continuationData: Foundation.Collections.ValueSet;
+ folder: Storage.StorageFolder;
+
+ }
+ export interface IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ }
+ export interface IActivatedEventArgsWithUser extends IActivatedEventArgs {
+ user: System.User;
+ }
+ export interface IApplicationViewActivatedEventArgs extends IActivatedEventArgs {
+ currentlyShownApplicationViewId: number;
+ }
+ export interface IAppointmentsProviderActivatedEventArgs extends IActivatedEventArgs {
+ verb: string;
+ }
+ export interface IAppointmentsProviderAddAppointmentActivatedEventArgs extends IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs {
+ addAppointmentOperation: Appointments.AppointmentsProvider.AddAppointmentOperation;
+ }
+ export interface IAppointmentsProviderRemoveAppointmentActivatedEventArgs extends IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs {
+ removeAppointmentOperation: Appointments.AppointmentsProvider.RemoveAppointmentOperation;
+ }
+ export interface IAppointmentsProviderReplaceAppointmentActivatedEventArgs extends IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs {
+ replaceAppointmentOperation: Appointments.AppointmentsProvider.ReplaceAppointmentOperation;
+ }
+ export interface IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs extends IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs {
+ instanceStartDate: Date | null;
+ localId: string;
+ roamingId: string;
+ }
+ export interface IAppointmentsProviderShowTimeFrameActivatedEventArgs extends IAppointmentsProviderActivatedEventArgs, IActivatedEventArgs {
+ duration: number;
+ timeToShow: Date;
+ }
+ export interface IBackgroundActivatedEventArgs {
+ taskInstance: Background.IBackgroundTaskInstance;
+ }
+ export interface IBarcodeScannerPreviewActivatedEventArgs extends IActivatedEventArgs {
+ connectionId: string;
+ }
+ export interface ICachedFileUpdaterActivatedEventArgs extends IActivatedEventArgs {
+ cachedFileUpdaterUI: Storage.Provider.CachedFileUpdaterUI;
+ }
+ export interface ICameraSettingsActivatedEventArgs extends IActivatedEventArgs {
+ videoDeviceController: any;
+ videoDeviceExtension: any;
+ }
+ export interface ICommandLineActivatedEventArgs extends IActivatedEventArgs {
+ operation: CommandLineActivationOperation;
+ }
+ export interface IContactActivatedEventArgs extends IActivatedEventArgs {
+ verb: string;
+ }
+ export interface IContactCallActivatedEventArgs extends IContactActivatedEventArgs, IActivatedEventArgs {
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+ }
+ export interface IContactMapActivatedEventArgs extends IContactActivatedEventArgs, IActivatedEventArgs {
+ address: Contacts.ContactAddress;
+ contact: Contacts.Contact;
+ }
+ export interface IContactMessageActivatedEventArgs extends IContactActivatedEventArgs, IActivatedEventArgs {
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+ }
+ export interface IContactPanelActivatedEventArgs {
+ contact: Contacts.Contact;
+ contactPanel: Contacts.ContactPanel;
+ }
+ export interface IContactPickerActivatedEventArgs extends IActivatedEventArgs {
+ contactPickerUI: Contacts.Provider.ContactPickerUI;
+ }
+ export interface IContactPostActivatedEventArgs extends IContactActivatedEventArgs, IActivatedEventArgs {
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+ }
+ export interface IContactsProviderActivatedEventArgs extends IActivatedEventArgs {
+ verb: string;
+ }
+ export interface IContactVideoCallActivatedEventArgs extends IContactActivatedEventArgs, IActivatedEventArgs {
+ contact: Contacts.Contact;
+ serviceId: string;
+ serviceUserId: string;
+ }
+ export interface IContinuationActivatedEventArgs extends IActivatedEventArgs {
+ continuationData: Foundation.Collections.ValueSet;
+ }
+ export interface IDeviceActivatedEventArgs extends IActivatedEventArgs {
+ deviceInformationId: string;
+ verb: string;
+ }
+ export interface IDevicePairingActivatedEventArgs extends IActivatedEventArgs {
+ deviceInformation: Devices.Enumeration.DeviceInformation;
+ }
+ export interface IDialReceiverActivatedEventArgs extends ILaunchActivatedEventArgs, IActivatedEventArgs {
+ appName: string;
+ }
+ export interface IFileActivatedEventArgs extends IActivatedEventArgs {
+ files: Storage.IStorageItem[];
+ verb: string;
+ }
+ export interface IFileActivatedEventArgsWithCallerPackageFamilyName extends IActivatedEventArgs {
+ callerPackageFamilyName: string;
+ }
+ export interface IFileActivatedEventArgsWithNeighboringFiles extends IFileActivatedEventArgs, IActivatedEventArgs {
+ neighboringFilesQuery: Storage.Search.StorageFileQueryResult;
+ }
+ export interface IFileOpenPickerActivatedEventArgs extends IActivatedEventArgs {
+ fileOpenPickerUI: Storage.Pickers.Provider.FileOpenPickerUI;
+ }
+ export interface IFileOpenPickerActivatedEventArgs2 {
+ callerPackageFamilyName: string;
+ }
+ export interface IFileOpenPickerContinuationEventArgs extends IContinuationActivatedEventArgs, IActivatedEventArgs {
+ files: Storage.StorageFile[];
+ }
+ export interface IFileSavePickerActivatedEventArgs extends IActivatedEventArgs {
+ fileSavePickerUI: Storage.Pickers.Provider.FileSavePickerUI;
+ }
+ export interface IFileSavePickerActivatedEventArgs2 {
+ callerPackageFamilyName: string;
+ enterpriseId: string;
+ }
+ export interface IFileSavePickerContinuationEventArgs extends IContinuationActivatedEventArgs, IActivatedEventArgs {
+ file: Storage.StorageFile;
+ }
+ export interface IFolderPickerContinuationEventArgs extends IContinuationActivatedEventArgs, IActivatedEventArgs {
+ folder: Storage.StorageFolder;
+ }
+ export interface ILaunchActivatedEventArgs extends IActivatedEventArgs {
+ __arguments: string;
+ tileId: string;
+ }
+ export interface ILaunchActivatedEventArgs2 extends ILaunchActivatedEventArgs, IActivatedEventArgs {
+ tileActivatedInfo: TileActivatedInfo;
+ }
+ export interface ILockScreenActivatedEventArgs extends IActivatedEventArgs {
+ info: any;
+ }
+ export interface ILockScreenCallActivatedEventArgs extends ILaunchActivatedEventArgs, IActivatedEventArgs {
+ callUI: Calls.LockScreenCallUI;
+ }
+ export interface IPickerReturnedActivatedEventArgs extends IActivatedEventArgs {
+ pickerOperationId: string;
+ }
+ export interface IPrelaunchActivatedEventArgs extends IActivatedEventArgs {
+ prelaunchActivated: Boolean;
+ }
+ export interface IPrint3DWorkflowActivatedEventArgs extends IActivatedEventArgs {
+ workflow: Devices.Printers.Extensions.Print3DWorkflow;
+ }
+ export interface IPrintTaskSettingsActivatedEventArgs extends IActivatedEventArgs {
+ configuration: Devices.Printers.Extensions.PrintTaskConfiguration;
+ }
+ export interface IProtocolActivatedEventArgs extends IActivatedEventArgs {
+ uri: Foundation.Uri;
+ }
+ export interface IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData extends IActivatedEventArgs {
+ callerPackageFamilyName: string;
+ data: Foundation.Collections.ValueSet;
+ }
+ export interface IProtocolForResultsActivatedEventArgs extends IActivatedEventArgs {
+ protocolForResultsOperation: System.ProtocolForResultsOperation;
+ }
+ export interface IRestrictedLaunchActivatedEventArgs extends IActivatedEventArgs {
+ sharedContext: any;
+ }
+ export interface ISearchActivatedEventArgs extends IActivatedEventArgs {
+ language: string;
+ queryText: string;
+ }
+ export interface ISearchActivatedEventArgsWithLinguisticDetails {
+ linguisticDetails: Search.SearchPaneQueryLinguisticDetails;
+ }
+ export interface IShareTargetActivatedEventArgs extends IActivatedEventArgs {
+ shareOperation: DataTransfer.ShareTarget.ShareOperation;
+ }
+ export interface IStartupTaskActivatedEventArgs extends IActivatedEventArgs {
+ taskId: string;
+ }
+ export interface IToastNotificationActivatedEventArgs extends IActivatedEventArgs {
+ argument: string;
+ userInput: Foundation.Collections.ValueSet;
+ }
+ export interface IUserDataAccountProviderActivatedEventArgs extends IActivatedEventArgs {
+ operation: UserDataAccounts.Provider.IUserDataAccountProviderOperation;
+ }
+ export interface IViewSwitcherProvider extends IActivatedEventArgs {
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+ }
+ export interface IVoiceCommandActivatedEventArgs extends IActivatedEventArgs {
+ result: Media.SpeechRecognition.SpeechRecognitionResult;
+ }
+ export interface IWalletActionActivatedEventArgs extends IActivatedEventArgs {
+ actionId: string;
+ actionKind: Wallet.WalletActionKind;
+ itemId: string;
+ }
+ export interface IWebAccountProviderActivatedEventArgs extends IActivatedEventArgs {
+ operation: Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+ }
+ export interface IWebAuthenticationBrokerContinuationEventArgs extends IContinuationActivatedEventArgs, IActivatedEventArgs {
+ webAuthenticationResult: Security.Authentication.Web.WebAuthenticationResult;
+ }
+ export class LaunchActivatedEventArgs implements ILaunchActivatedEventArgs, IActivatedEventArgs, IApplicationViewActivatedEventArgs, IPrelaunchActivatedEventArgs, IViewSwitcherProvider, ILaunchActivatedEventArgs2, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ __arguments: string;
+ tileId: string;
+ tileActivatedInfo: TileActivatedInfo;
+ prelaunchActivated: Boolean;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class LockScreenActivatedEventArgs implements ILockScreenActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ info: any;
+
+ }
+ export class LockScreenCallActivatedEventArgs implements ILockScreenCallActivatedEventArgs, ILaunchActivatedEventArgs, IActivatedEventArgs, IApplicationViewActivatedEventArgs, IViewSwitcherProvider {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ currentlyShownApplicationViewId: number;
+ __arguments: string;
+ tileId: string;
+ callUI: Calls.LockScreenCallUI;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class LockScreenComponentActivatedEventArgs implements IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+
+ }
+ export class PickerReturnedActivatedEventArgs implements IPickerReturnedActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ pickerOperationId: string;
+
+ }
+ export class Print3DWorkflowActivatedEventArgs implements IPrint3DWorkflowActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ workflow: Devices.Printers.Extensions.Print3DWorkflow;
+
+ }
+ export class PrintTaskSettingsActivatedEventArgs implements IPrintTaskSettingsActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ configuration: Devices.Printers.Extensions.PrintTaskConfiguration;
+
+ }
+ export class ProtocolActivatedEventArgs implements IProtocolActivatedEventArgs, IActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IApplicationViewActivatedEventArgs, IViewSwitcherProvider, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ uri: Foundation.Uri;
+ callerPackageFamilyName: string;
+ data: Foundation.Collections.ValueSet;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class ProtocolForResultsActivatedEventArgs implements IProtocolForResultsActivatedEventArgs, IActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IApplicationViewActivatedEventArgs, IViewSwitcherProvider, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ uri: Foundation.Uri;
+ callerPackageFamilyName: string;
+ data: Foundation.Collections.ValueSet;
+ protocolForResultsOperation: System.ProtocolForResultsOperation;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class RestrictedLaunchActivatedEventArgs implements IRestrictedLaunchActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ sharedContext: any;
+
+ }
+ export class SearchActivatedEventArgs implements ISearchActivatedEventArgs, IActivatedEventArgs, IApplicationViewActivatedEventArgs, ISearchActivatedEventArgsWithLinguisticDetails, IViewSwitcherProvider, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ language: string;
+ queryText: string;
+ linguisticDetails: Search.SearchPaneQueryLinguisticDetails;
+ viewSwitcher: UI.ViewManagement.ActivationViewSwitcher;
+
+ }
+ export class ShareTargetActivatedEventArgs implements IShareTargetActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ shareOperation: DataTransfer.ShareTarget.ShareOperation;
+
+ }
+ export class SplashScreen implements ISplashScreen {
+ imageLocation: Foundation.Rect;
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`SplashScreen::addEventListener: ${name}`);
+ switch (name) {
+ case "dismissed": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class StartupTaskActivatedEventArgs implements IStartupTaskActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ taskId: string;
+
+ }
+ export class TileActivatedInfo implements ITileActivatedInfo {
+ recentlyShownNotifications: UI.Notifications.ShownTileNotification[];
+
+ }
+ export class ToastNotificationActivatedEventArgs implements IToastNotificationActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ currentlyShownApplicationViewId: number;
+ argument: string;
+ userInput: Foundation.Collections.ValueSet;
+
+ }
+ export class UserDataAccountProviderActivatedEventArgs implements IUserDataAccountProviderActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ operation: UserDataAccounts.Provider.IUserDataAccountProviderOperation;
+
+ }
+ export class VoiceCommandActivatedEventArgs implements IVoiceCommandActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ result: Media.SpeechRecognition.SpeechRecognitionResult;
+
+ }
+ export class WalletActionActivatedEventArgs implements IWalletActionActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ actionId: string;
+ actionKind: Wallet.WalletActionKind;
+ itemId: string;
+
+ }
+ export class WebAccountProviderActivatedEventArgs implements IWebAccountProviderActivatedEventArgs, IActivatedEventArgs, IActivatedEventArgsWithUser {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ user: System.User;
+ operation: Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+
+ }
+ export class WebAuthenticationBrokerContinuationEventArgs implements IWebAuthenticationBrokerContinuationEventArgs, IContinuationActivatedEventArgs, IActivatedEventArgs {
+ kind: ActivationKind;
+ previousExecutionState: ApplicationExecutionState;
+ splashScreen: SplashScreen;
+ continuationData: Foundation.Collections.ValueSet;
+ webAuthenticationResult: Security.Authentication.Web.WebAuthenticationResult;
+
+ }
+ export interface WebUISearchActivatedEventsContract {
+ }
+ }
+ export enum AddResourcePackageOptions {
+ none,
+ forceTargetAppShutdown,
+ applyUpdateIfAvailable,
+ }
+ export class AppDisplayInfo implements IAppDisplayInfo {
+ description: string;
+ displayName: string;
+
+ getLogo(size: Foundation.Size): Storage.Streams.RandomAccessStreamReference {
+ throw new Error('shimmed function AppDisplayInfo.getLogo');
+ }
+
+ }
+ export namespace AppExtensions {
+ export class AppExtension implements IAppExtension {
+ appInfo: AppInfo;
+ description: string;
+ displayName: string;
+ id: string;
+ package: Package;
+
+ getExtensionPropertiesAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppExtension.getExtensionPropertiesAsync');
+ }
+
+ getPublicFolderAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppExtension.getPublicFolderAsync');
+ }
+
+ }
+ export class AppExtensionCatalog implements IAppExtensionCatalog {
+ findAllAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppExtensionCatalog.findAllAsync');
+ }
+
+ requestRemovePackageAsync(packageFullName: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppExtensionCatalog.requestRemovePackageAsync');
+ }
+
+ static open(appExtensionName: string): AppExtensionCatalog {
+ throw new Error('shimmed function AppExtensionCatalog.open');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`AppExtensionCatalog::addEventListener: ${name}`);
+ switch (name) {
+ case "packageinstalled": // Foundation.TypedEventHandler
+ case "packagestatuschanged": // Foundation.TypedEventHandler
+ case "packageuninstalling": // Foundation.TypedEventHandler
+ case "packageupdated": // Foundation.TypedEventHandler
+ case "packageupdating": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class AppExtensionPackageInstalledEventArgs implements IAppExtensionPackageInstalledEventArgs {
+ appExtensionName: string;
+ extensions: AppExtension[];
+ package: Package;
+
+ }
+ export class AppExtensionPackageStatusChangedEventArgs implements IAppExtensionPackageStatusChangedEventArgs {
+ appExtensionName: string;
+ package: Package;
+
+ }
+ export class AppExtensionPackageUninstallingEventArgs implements IAppExtensionPackageUninstallingEventArgs {
+ appExtensionName: string;
+ package: Package;
+
+ }
+ export class AppExtensionPackageUpdatedEventArgs implements IAppExtensionPackageUpdatedEventArgs {
+ appExtensionName: string;
+ extensions: AppExtension[];
+ package: Package;
+
+ }
+ export class AppExtensionPackageUpdatingEventArgs implements IAppExtensionPackageUpdatingEventArgs {
+ appExtensionName: string;
+ package: Package;
+
+ }
+ }
+ export class AppInfo implements IAppInfo {
+ appUserModelId: string;
+ displayInfo: AppDisplayInfo;
+ id: string;
+ packageFamilyName: string;
+
+ }
+ export class AppInstallerInfo implements IAppInstallerInfo {
+ uri: Foundation.Uri;
+
+ }
+ export class AppInstance implements IAppInstance {
+ isCurrentInstance: Boolean;
+ key: string;
+ static recommendedInstance: AppInstance;
+
+ redirectActivationTo(): void {
+ console.warn('shimmed function AppInstance.redirectActivationTo');
+ }
+
+ static getActivatedEventArgs(): Activation.IActivatedEventArgs {
+ throw new Error('shimmed function AppInstance.getActivatedEventArgs');
+ }
+
+ static findOrRegisterInstanceForKey(key: string): AppInstance {
+ throw new Error('shimmed function AppInstance.findOrRegisterInstanceForKey');
+ }
+
+ static unregister(): void {
+ console.warn('shimmed function AppInstance.unregister');
+ }
+
+ static getInstances(): AppInstance[] {
+ throw new Error('shimmed function AppInstance.getInstances');
+ }
+
+ }
+ export namespace Appointments {
+ export class Appointment implements IAppointment, IAppointment2, IAppointment3 {
+ // constructor();
+ location: string = '';
+ allDay: Boolean = false;
+ organizer: AppointmentOrganizer;
+ duration: number = 0;
+ details: string = '';
+ busyStatus: AppointmentBusyStatus = AppointmentBusyStatus.busy;
+ recurrence: AppointmentRecurrence;
+ subject: string = '';
+ uri: Foundation.Uri;
+ startTime: Date = new Date(1616785453704);
+ sensitivity: AppointmentSensitivity = AppointmentSensitivity.public;
+ reminder: number | null;
+ invitees: AppointmentInvitee[] = [ ];
+ allowNewTimeProposal: Boolean = true;
+ userResponse: AppointmentParticipantResponse = AppointmentParticipantResponse.none;
+ roamingId: string = '';
+ replyTime: Date | null;
+ isResponseRequested: Boolean = true;
+ isOrganizedByUser: Boolean = false;
+ isCanceledMeeting: Boolean = false;
+ onlineMeetingLink: string = '';
+ hasInvitees: Boolean = false;
+ calendarId: string = '';
+ localId: string = '';
+ originalStartTime: Date | null;
+ remoteChangeNumber: number = 0;
+ detailsKind: AppointmentDetailsKind = AppointmentDetailsKind.plainText;
+ changeNumber: number = 0;
+
+ }
+ export enum AppointmentBusyStatus {
+ busy,
+ tentative,
+ free,
+ outOfOffice,
+ workingElsewhere,
+ }
+ export class AppointmentCalendar implements IAppointmentCalendar, IAppointmentCalendar2, IAppointmentCalendar3 {
+ summaryCardView: AppointmentSummaryCardView;
+ otherAppWriteAccess: AppointmentCalendarOtherAppWriteAccess;
+ displayColor: UI.Color;
+ isHidden: Boolean;
+ displayName: string;
+ otherAppReadAccess: AppointmentCalendarOtherAppReadAccess;
+ localId: string;
+ sourceDisplayName: string;
+ canCancelMeetings: Boolean;
+ canNotifyInvitees: Boolean;
+ remoteId: string;
+ mustNofityInvitees: Boolean;
+ canUpdateMeetingResponses: Boolean;
+ canProposeNewTimeForMeetings: Boolean;
+ canCreateOrUpdateAppointments: Boolean;
+ canForwardMeetings: Boolean;
+ syncManager: AppointmentCalendarSyncManager;
+ userDataAccountId: string;
+
+ findAppointmentsAsync(rangeStart: Date, rangeLength: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findAppointmentsAsync');
+ }
+
+ findAppointmentsAsync_1(rangeStart: Date, rangeLength: number, options: FindAppointmentsOptions): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findAppointmentsAsync_1');
+ }
+
+ findExceptionsFromMasterAsync(masterLocalId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findExceptionsFromMasterAsync');
+ }
+
+ findAllInstancesAsync(masterLocalId: string, rangeStart: Date, rangeLength: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findAllInstancesAsync');
+ }
+
+ findAllInstancesAsync_1(masterLocalId: string, rangeStart: Date, rangeLength: number, pOptions: FindAppointmentsOptions): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findAllInstancesAsync_1');
+ }
+
+ getAppointmentAsync(localId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.getAppointmentAsync');
+ }
+
+ getAppointmentInstanceAsync(localId: string, instanceStartTime: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.getAppointmentInstanceAsync');
+ }
+
+ findUnexpandedAppointmentsAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findUnexpandedAppointmentsAsync');
+ }
+
+ findUnexpandedAppointmentsAsync_1(options: FindAppointmentsOptions): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.findUnexpandedAppointmentsAsync_1');
+ }
+
+ deleteAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendar.deleteAsync');
+ }
+
+ saveAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendar.saveAsync');
+ }
+
+ deleteAppointmentAsync(localId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendar.deleteAppointmentAsync');
+ }
+
+ deleteAppointmentInstanceAsync(localId: string, instanceStartTime: Date): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendar.deleteAppointmentInstanceAsync');
+ }
+
+ saveAppointmentAsync(pAppointment: Appointment): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendar.saveAppointmentAsync');
+ }
+
+ tryCreateOrUpdateAppointmentAsync(appointment: Appointment, notifyInvitees: Boolean): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.tryCreateOrUpdateAppointmentAsync');
+ }
+
+ tryCancelMeetingAsync(meeting: Appointment, subject: string, comment: string, notifyInvitees: Boolean): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.tryCancelMeetingAsync');
+ }
+
+ tryForwardMeetingAsync(meeting: Appointment, invitees: Foundation.Collections.IIterable, subject: string, forwardHeader: string, comment: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.tryForwardMeetingAsync');
+ }
+
+ tryProposeNewTimeForMeetingAsync(meeting: Appointment, newStartTime: Date, newDuration: number, subject: string, comment: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.tryProposeNewTimeForMeetingAsync');
+ }
+
+ tryUpdateMeetingResponseAsync(meeting: Appointment, response: AppointmentParticipantResponse, subject: string, comment: string, sendUpdate: Boolean): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendar.tryUpdateMeetingResponseAsync');
+ }
+
+ registerSyncManagerAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendar.registerSyncManagerAsync');
+ }
+
+ }
+ export enum AppointmentCalendarOtherAppReadAccess {
+ systemOnly,
+ limited,
+ full,
+ none,
+ }
+ export enum AppointmentCalendarOtherAppWriteAccess {
+ none,
+ systemOnly,
+ limited,
+ }
+ export class AppointmentCalendarSyncManager implements IAppointmentCalendarSyncManager, IAppointmentCalendarSyncManager2 {
+ status: AppointmentCalendarSyncStatus;
+ lastSuccessfulSyncTime: Date;
+ lastAttemptedSyncTime: Date;
+
+ syncAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentCalendarSyncManager.syncAsync');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`AppointmentCalendarSyncManager::addEventListener: ${name}`);
+ switch (name) {
+ case "syncstatuschanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export enum AppointmentCalendarSyncStatus {
+ idle,
+ syncing,
+ upToDate,
+ authenticationError,
+ policyError,
+ unknownError,
+ manualAccountRemovalRequired,
+ }
+ export class AppointmentConflictResult implements IAppointmentConflictResult {
+ date: Date;
+ type: AppointmentConflictType;
+
+ }
+ export enum AppointmentConflictType {
+ none,
+ adjacent,
+ overlap,
+ }
+ export enum AppointmentDaysOfWeek {
+ none,
+ sunday,
+ monday,
+ tuesday = 4,
+ wednesday = 8,
+ thursday = 16,
+ friday = 32,
+ saturday = 64,
+ }
+ export enum AppointmentDetailsKind {
+ plainText,
+ html,
+ }
+ export class AppointmentException implements IAppointmentException {
+ appointment: Appointment;
+ exceptionProperties: string[];
+ isDeleted: Boolean;
+
+ }
+ export class AppointmentInvitee implements IAppointmentInvitee, IAppointmentParticipant {
+ // constructor();
+ role: AppointmentParticipantRole = AppointmentParticipantRole.requiredAttendee;
+ response: AppointmentParticipantResponse = AppointmentParticipantResponse.none;
+ displayName: string = '';
+ address: string = '';
+
+ }
+ export class AppointmentManager {
+ static getForUser(user: System.User): AppointmentManagerForUser {
+ throw new Error('shimmed function AppointmentManager.getForUser');
+ }
+
+ static showAppointmentDetailsAsync(appointmentId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentManager.showAppointmentDetailsAsync');
+ }
+
+ static showAppointmentDetailsAsync_1(appointmentId: string, instanceStartDate: Date): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentManager.showAppointmentDetailsAsync_1');
+ }
+
+ static showEditNewAppointmentAsync(appointment: Appointment): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showEditNewAppointmentAsync');
+ }
+
+ static requestStoreAsync(options: AppointmentStoreAccessType): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.requestStoreAsync');
+ }
+
+ static showAddAppointmentAsync(appointment: Appointment, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showAddAppointmentAsync');
+ }
+
+ static showAddAppointmentAsync_1(appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showAddAppointmentAsync_1');
+ }
+
+ static showReplaceAppointmentAsync(appointmentId: string, appointment: Appointment, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showReplaceAppointmentAsync');
+ }
+
+ static showReplaceAppointmentAsync_1(appointmentId: string, appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showReplaceAppointmentAsync_1');
+ }
+
+ static showReplaceAppointmentAsync_2(appointmentId: string, appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement, instanceStartDate: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showReplaceAppointmentAsync_2');
+ }
+
+ static showRemoveAppointmentAsync(appointmentId: string, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showRemoveAppointmentAsync');
+ }
+
+ static showRemoveAppointmentAsync_1(appointmentId: string, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showRemoveAppointmentAsync_1');
+ }
+
+ static showRemoveAppointmentAsync_2(appointmentId: string, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement, instanceStartDate: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManager.showRemoveAppointmentAsync_2');
+ }
+
+ static showTimeFrameAsync(timeToShow: Date, duration: number): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentManager.showTimeFrameAsync');
+ }
+
+ }
+ export class AppointmentManagerForUser implements IAppointmentManagerForUser {
+ user: System.User;
+
+ showAddAppointmentAsync(appointment: Appointment, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showAddAppointmentAsync');
+ }
+
+ showAddAppointmentAsync_1(appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showAddAppointmentAsync_1');
+ }
+
+ showReplaceAppointmentAsync(appointmentId: string, appointment: Appointment, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showReplaceAppointmentAsync');
+ }
+
+ showReplaceAppointmentAsync_1(appointmentId: string, appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showReplaceAppointmentAsync_1');
+ }
+
+ showReplaceAppointmentAsync_2(appointmentId: string, appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement, instanceStartDate: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showReplaceAppointmentAsync_2');
+ }
+
+ showRemoveAppointmentAsync(appointmentId: string, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showRemoveAppointmentAsync');
+ }
+
+ showRemoveAppointmentAsync_1(appointmentId: string, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showRemoveAppointmentAsync_1');
+ }
+
+ showRemoveAppointmentAsync_2(appointmentId: string, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement, instanceStartDate: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showRemoveAppointmentAsync_2');
+ }
+
+ showTimeFrameAsync(timeToShow: Date, duration: number): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentManagerForUser.showTimeFrameAsync');
+ }
+
+ showAppointmentDetailsAsync(appointmentId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentManagerForUser.showAppointmentDetailsAsync');
+ }
+
+ showAppointmentDetailsAsync_1(appointmentId: string, instanceStartDate: Date): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentManagerForUser.showAppointmentDetailsAsync_1');
+ }
+
+ showEditNewAppointmentAsync(appointment: Appointment): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.showEditNewAppointmentAsync');
+ }
+
+ requestStoreAsync(options: AppointmentStoreAccessType): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentManagerForUser.requestStoreAsync');
+ }
+
+ }
+ export class AppointmentOrganizer implements IAppointmentParticipant {
+ // constructor();
+ displayName: string = '';
+ address: string = '';
+
+ }
+ export enum AppointmentParticipantResponse {
+ none,
+ tentative,
+ accepted,
+ declined,
+ unknown,
+ }
+ export enum AppointmentParticipantRole {
+ requiredAttendee,
+ optionalAttendee,
+ resource,
+ }
+ export class AppointmentProperties {
+ static hasInvitees: string = 'Appointment.HasInvitees';
+ static allDay: string = 'Appointment.AllDay';
+ static allowNewTimeProposal: string = 'Appointment.AllowNewTimeProposal';
+ static busyStatus: string = 'Appointment.BusyStatus';
+ static defaultProperties: string[] = [ 'Appointment.Subject', 'Appointment.Location', 'Appointment.StartTime', 'Appointment.Duration', 'Appointment.BusyStatus', 'Appointment.AllDay', 'Appointment.ParentFolderId', 'Appointment.Recurrence', 'Appointment.RemoteId', 'Appointment.OriginalStartTime', 'Appointment.ChangeNumber' ];
+ static details: string = 'Appointment.Details';
+ static duration: string = 'Appointment.Duration';
+ static recurrence: string = 'Appointment.Recurrence';
+ static invitees: string = 'Appointment.Invitees';
+ static isCanceledMeeting: string = 'Appointment.IsCanceledMeeting';
+ static isOrganizedByUser: string = 'Appointment.IsOrganizedByUser';
+ static isResponseRequested: string = 'Appointment.IsResponseRequested';
+ static location: string = 'Appointment.Location';
+ static onlineMeetingLink: string = 'Appointment.OnlineMeetingLink';
+ static organizer: string = 'Appointment.Organizer';
+ static originalStartTime: string = 'Appointment.OriginalStartTime';
+ static reminder: string = 'Appointment.Reminder';
+ static replyTime: string = 'Appointment.ReplyTime';
+ static sensitivity: string = 'Appointment.Sensitivity';
+ static startTime: string = 'Appointment.StartTime';
+ static subject: string = 'Appointment.Subject';
+ static uri: string = 'Appointment.Uri';
+ static userResponse: string = 'Appointment.UserResponse';
+ static detailsKind: string = 'Appointment.DetailsKind';
+ static remoteChangeNumber: string = 'Appointment.RemoteChangeNumber';
+ static changeNumber: string = 'Appointment.ChangeNumber';
+
+ }
+ export class AppointmentRecurrence implements IAppointmentRecurrence, IAppointmentRecurrence2, IAppointmentRecurrence3 {
+ // constructor();
+ unit: AppointmentRecurrenceUnit = AppointmentRecurrenceUnit.daily;
+ occurrences: number | null;
+ month: number = 1;
+ interval: number = 1;
+ daysOfWeek: AppointmentDaysOfWeek = AppointmentDaysOfWeek.none;
+ day: number = 1;
+ weekOfMonth: AppointmentWeekOfMonth = AppointmentWeekOfMonth.first;
+ until: Date | null;
+ timeZone: string = '';
+ recurrenceType: RecurrenceType = RecurrenceType.master;
+ calendarIdentifier: string = '';
+
+ }
+ export enum AppointmentRecurrenceUnit {
+ daily,
+ weekly,
+ monthly,
+ monthlyOnDay,
+ yearly,
+ yearlyOnDay,
+ }
+ export enum AppointmentSensitivity {
+ public,
+ private,
+ }
+ export namespace AppointmentsProvider {
+ export class AddAppointmentOperation implements IAddAppointmentOperation {
+ appointmentInformation: Appointment;
+ sourcePackageFamilyName: string;
+
+ reportCompleted(itemId: string): void {
+ console.warn('shimmed function AddAppointmentOperation.reportCompleted');
+ }
+
+ reportCanceled(): void {
+ console.warn('shimmed function AddAppointmentOperation.reportCanceled');
+ }
+
+ reportError(value: string): void {
+ console.warn('shimmed function AddAppointmentOperation.reportError');
+ }
+
+ dismissUI(): void {
+ console.warn('shimmed function AddAppointmentOperation.dismissUI');
+ }
+
+ }
+ export class AppointmentsProviderLaunchActionVerbs {
+ static addAppointment: string = 'Windows.AppointmentsProvider.AddAppointment';
+ static removeAppointment: string = 'Windows.AppointmentsProvider.RemoveAppointment';
+ static replaceAppointment: string = 'Windows.AppointmentsProvider.ReplaceAppointment';
+ static showTimeFrame: string = 'Windows.AppointmentsProvider.ShowTimeFrame';
+ static showAppointmentDetails: string = 'Windows.AppointmentsProvider.ShowAppointmentDetails';
+
+ }
+ export class RemoveAppointmentOperation implements IRemoveAppointmentOperation {
+ appointmentId: string;
+ instanceStartDate: Date | null;
+ sourcePackageFamilyName: string;
+
+ reportCompleted(): void {
+ console.warn('shimmed function RemoveAppointmentOperation.reportCompleted');
+ }
+
+ reportCanceled(): void {
+ console.warn('shimmed function RemoveAppointmentOperation.reportCanceled');
+ }
+
+ reportError(value: string): void {
+ console.warn('shimmed function RemoveAppointmentOperation.reportError');
+ }
+
+ dismissUI(): void {
+ console.warn('shimmed function RemoveAppointmentOperation.dismissUI');
+ }
+
+ }
+ export class ReplaceAppointmentOperation implements IReplaceAppointmentOperation {
+ appointmentId: string;
+ appointmentInformation: Appointment;
+ instanceStartDate: Date | null;
+ sourcePackageFamilyName: string;
+
+ reportCompleted(itemId: string): void {
+ console.warn('shimmed function ReplaceAppointmentOperation.reportCompleted');
+ }
+
+ reportCanceled(): void {
+ console.warn('shimmed function ReplaceAppointmentOperation.reportCanceled');
+ }
+
+ reportError(value: string): void {
+ console.warn('shimmed function ReplaceAppointmentOperation.reportError');
+ }
+
+ dismissUI(): void {
+ console.warn('shimmed function ReplaceAppointmentOperation.dismissUI');
+ }
+
+ }
+ }
+ export class AppointmentStore implements IAppointmentStore, IAppointmentStore2, IAppointmentStore3 {
+ changeTracker: AppointmentStoreChangeTracker;
+
+ createAppointmentCalendarAsync(name: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.createAppointmentCalendarAsync');
+ }
+
+ getAppointmentCalendarAsync(calendarId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.getAppointmentCalendarAsync');
+ }
+
+ getAppointmentAsync(localId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.getAppointmentAsync');
+ }
+
+ getAppointmentInstanceAsync(localId: string, instanceStartTime: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.getAppointmentInstanceAsync');
+ }
+
+ findAppointmentCalendarsAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findAppointmentCalendarsAsync');
+ }
+
+ findAppointmentCalendarsAsync_1(options: FindAppointmentCalendarsOptions): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findAppointmentCalendarsAsync_1');
+ }
+
+ findAppointmentsAsync(rangeStart: Date, rangeLength: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findAppointmentsAsync');
+ }
+
+ findAppointmentsAsync_1(rangeStart: Date, rangeLength: number, options: FindAppointmentsOptions): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findAppointmentsAsync_1');
+ }
+
+ findConflictAsync(appointment: Appointment): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findConflictAsync');
+ }
+
+ findConflictAsync_1(appointment: Appointment, instanceStartTime: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findConflictAsync_1');
+ }
+
+ moveAppointmentAsync(appointment: Appointment, destinationCalendar: AppointmentCalendar): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentStore.moveAppointmentAsync');
+ }
+
+ showAddAppointmentAsync(appointment: Appointment, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.showAddAppointmentAsync');
+ }
+
+ showReplaceAppointmentAsync(localId: string, appointment: Appointment, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.showReplaceAppointmentAsync');
+ }
+
+ showReplaceAppointmentAsync_1(localId: string, appointment: Appointment, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement, instanceStartDate: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.showReplaceAppointmentAsync_1');
+ }
+
+ showRemoveAppointmentAsync(localId: string, selection: Foundation.Rect): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.showRemoveAppointmentAsync');
+ }
+
+ showRemoveAppointmentAsync_1(localId: string, selection: Foundation.Rect, preferredPlacement: UI.Popups.Placement, instanceStartDate: Date): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.showRemoveAppointmentAsync_1');
+ }
+
+ showAppointmentDetailsAsync(localId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentStore.showAppointmentDetailsAsync');
+ }
+
+ showAppointmentDetailsAsync_1(localId: string, instanceStartDate: Date): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentStore.showAppointmentDetailsAsync_1');
+ }
+
+ showEditNewAppointmentAsync(appointment: Appointment): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.showEditNewAppointmentAsync');
+ }
+
+ findLocalIdsFromRoamingIdAsync(roamingId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.findLocalIdsFromRoamingIdAsync');
+ }
+
+ createAppointmentCalendarAsync_1(name: string, userDataAccountId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStore.createAppointmentCalendarAsync_1');
+ }
+
+ getChangeTracker(identity: string): AppointmentStoreChangeTracker {
+ throw new Error('shimmed function AppointmentStore.getChangeTracker');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`AppointmentStore::addEventListener: ${name}`);
+ switch (name) {
+ case "storechanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export enum AppointmentStoreAccessType {
+ appCalendarsReadWrite,
+ allCalendarsReadOnly,
+ allCalendarsReadWrite,
+ }
+ export class AppointmentStoreChange implements IAppointmentStoreChange, IAppointmentStoreChange2 {
+ appointment: Appointment;
+ changeType: AppointmentStoreChangeType;
+ appointmentCalendar: AppointmentCalendar;
+
+ }
+ export class AppointmentStoreChangedDeferral implements IAppointmentStoreChangedDeferral {
+ complete(): void {
+ console.warn('shimmed function AppointmentStoreChangedDeferral.complete');
+ }
+
+ }
+ export class AppointmentStoreChangedEventArgs implements IAppointmentStoreChangedEventArgs {
+ getDeferral(): AppointmentStoreChangedDeferral {
+ throw new Error('shimmed function AppointmentStoreChangedEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentStoreChangeReader implements IAppointmentStoreChangeReader {
+ readBatchAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppointmentStoreChangeReader.readBatchAsync');
+ }
+
+ acceptChanges(): void {
+ console.warn('shimmed function AppointmentStoreChangeReader.acceptChanges');
+ }
+
+ acceptChangesThrough(lastChangeToAccept: AppointmentStoreChange): void {
+ console.warn('shimmed function AppointmentStoreChangeReader.acceptChangesThrough');
+ }
+
+ }
+ export class AppointmentStoreChangeTracker implements IAppointmentStoreChangeTracker, IAppointmentStoreChangeTracker2 {
+ isTracking: Boolean;
+
+ getChangeReader(): AppointmentStoreChangeReader {
+ throw new Error('shimmed function AppointmentStoreChangeTracker.getChangeReader');
+ }
+
+ enable(): void {
+ console.warn('shimmed function AppointmentStoreChangeTracker.enable');
+ }
+
+ reset(): void {
+ console.warn('shimmed function AppointmentStoreChangeTracker.reset');
+ }
+
+ }
+ export enum AppointmentStoreChangeType {
+ appointmentCreated,
+ appointmentModified,
+ appointmentDeleted,
+ changeTrackingLost,
+ calendarCreated,
+ calendarModified,
+ calendarDeleted,
+ }
+ export class AppointmentStoreNotificationTriggerDetails implements IAppointmentStoreNotificationTriggerDetails {
+ }
+ export enum AppointmentSummaryCardView {
+ system,
+ app,
+ }
+ export enum AppointmentWeekOfMonth {
+ first,
+ second,
+ third,
+ fourth,
+ last,
+ }
+ export namespace DataProvider {
+ export class AppointmentCalendarCancelMeetingRequest implements IAppointmentCalendarCancelMeetingRequest {
+ appointmentCalendarLocalId: string;
+ appointmentLocalId: string;
+ appointmentOriginalStartTime: Date | null;
+ comment: string;
+ notifyInvitees: Boolean;
+ subject: string;
+
+ reportCompletedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarCancelMeetingRequest.reportCompletedAsync');
+ }
+
+ reportFailedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarCancelMeetingRequest.reportFailedAsync');
+ }
+
+ }
+ export class AppointmentCalendarCancelMeetingRequestEventArgs implements IAppointmentCalendarCancelMeetingRequestEventArgs {
+ request: AppointmentCalendarCancelMeetingRequest;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function AppointmentCalendarCancelMeetingRequestEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentCalendarCreateOrUpdateAppointmentRequest implements IAppointmentCalendarCreateOrUpdateAppointmentRequest {
+ appointment: Appointment;
+ appointmentCalendarLocalId: string;
+ changedProperties: string[];
+ notifyInvitees: Boolean;
+
+ reportCompletedAsync(createdOrUpdatedAppointment: Appointment): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarCreateOrUpdateAppointmentRequest.reportCompletedAsync');
+ }
+
+ reportFailedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarCreateOrUpdateAppointmentRequest.reportFailedAsync');
+ }
+
+ }
+ export class AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs implements IAppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs {
+ request: AppointmentCalendarCreateOrUpdateAppointmentRequest;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentCalendarForwardMeetingRequest implements IAppointmentCalendarForwardMeetingRequest {
+ appointmentCalendarLocalId: string;
+ appointmentLocalId: string;
+ appointmentOriginalStartTime: Date | null;
+ comment: string;
+ forwardHeader: string;
+ invitees: AppointmentInvitee[];
+ subject: string;
+
+ reportCompletedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarForwardMeetingRequest.reportCompletedAsync');
+ }
+
+ reportFailedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarForwardMeetingRequest.reportFailedAsync');
+ }
+
+ }
+ export class AppointmentCalendarForwardMeetingRequestEventArgs implements IAppointmentCalendarForwardMeetingRequestEventArgs {
+ request: AppointmentCalendarForwardMeetingRequest;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function AppointmentCalendarForwardMeetingRequestEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentCalendarProposeNewTimeForMeetingRequest implements IAppointmentCalendarProposeNewTimeForMeetingRequest {
+ appointmentCalendarLocalId: string;
+ appointmentLocalId: string;
+ appointmentOriginalStartTime: Date | null;
+ comment: string;
+ newDuration: number;
+ newStartTime: Date;
+ subject: string;
+
+ reportCompletedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarProposeNewTimeForMeetingRequest.reportCompletedAsync');
+ }
+
+ reportFailedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarProposeNewTimeForMeetingRequest.reportFailedAsync');
+ }
+
+ }
+ export class AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs implements IAppointmentCalendarProposeNewTimeForMeetingRequestEventArgs {
+ request: AppointmentCalendarProposeNewTimeForMeetingRequest;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentCalendarSyncManagerSyncRequest implements IAppointmentCalendarSyncManagerSyncRequest {
+ appointmentCalendarLocalId: string;
+
+ reportCompletedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarSyncManagerSyncRequest.reportCompletedAsync');
+ }
+
+ reportFailedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarSyncManagerSyncRequest.reportFailedAsync');
+ }
+
+ }
+ export class AppointmentCalendarSyncManagerSyncRequestEventArgs implements IAppointmentCalendarSyncManagerSyncRequestEventArgs {
+ request: AppointmentCalendarSyncManagerSyncRequest;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function AppointmentCalendarSyncManagerSyncRequestEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentCalendarUpdateMeetingResponseRequest implements IAppointmentCalendarUpdateMeetingResponseRequest {
+ appointmentCalendarLocalId: string;
+ appointmentLocalId: string;
+ appointmentOriginalStartTime: Date | null;
+ comment: string;
+ response: AppointmentParticipantResponse;
+ sendUpdate: Boolean;
+ subject: string;
+
+ reportCompletedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarUpdateMeetingResponseRequest.reportCompletedAsync');
+ }
+
+ reportFailedAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function AppointmentCalendarUpdateMeetingResponseRequest.reportFailedAsync');
+ }
+
+ }
+ export class AppointmentCalendarUpdateMeetingResponseRequestEventArgs implements IAppointmentCalendarUpdateMeetingResponseRequestEventArgs {
+ request: AppointmentCalendarUpdateMeetingResponseRequest;
+
+ getDeferral(): Foundation.Deferral {
+ throw new Error('shimmed function AppointmentCalendarUpdateMeetingResponseRequestEventArgs.getDeferral');
+ }
+
+ }
+ export class AppointmentDataProviderConnection implements IAppointmentDataProviderConnection {
+ start(): void {
+ console.warn('shimmed function AppointmentDataProviderConnection.start');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`AppointmentDataProviderConnection::addEventListener: ${name}`);
+ switch (name) {
+ case "cancelmeetingrequested": // Foundation.TypedEventHandler
+ case "createorupdateappointmentrequested": // Foundation.TypedEventHandler
+ case "forwardmeetingrequested": // Foundation.TypedEventHandler
+ case "proposenewtimeformeetingrequested": // Foundation.TypedEventHandler
+ case "syncrequested": // Foundation.TypedEventHandler
+ case "updatemeetingresponserequested": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class AppointmentDataProviderTriggerDetails implements IAppointmentDataProviderTriggerDetails {
+ connection: AppointmentDataProviderConnection;
+
+ }
+ }
+ export enum FindAppointmentCalendarsOptions {
+ none,
+ includeHidden,
+ }
+ export class FindAppointmentsOptions implements IFindAppointmentsOptions {
+ // constructor();
+ maxCount: number = 4294967295;
+ includeHidden: Boolean = false;
+ calendarIds: string[] = [ ];
+ fetchProperties: string[] = [ ];
+
+ }
+ export interface IAppointmentParticipant {
+ address: string;
+ displayName: string;
+ }
+ export enum RecurrenceType {
+ master,
+ instance,
+ exceptionInstance,
+ }
+ }
+ export namespace AppService {
+ export class AppServiceCatalog {
+ static findAppServiceProvidersAsync(appServiceName: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceCatalog.findAppServiceProvidersAsync');
+ }
+
+ }
+ export class AppServiceClosedEventArgs implements IAppServiceClosedEventArgs {
+ status: AppServiceClosedStatus;
+
+ }
+ export enum AppServiceClosedStatus {
+ completed,
+ canceled,
+ resourceLimitsExceeded,
+ unknown,
+ }
+ export class AppServiceConnection implements IAppServiceConnection, IAppServiceConnection2, Foundation.IClosable {
+ // constructor();
+ packageFamilyName: string = '';
+ appServiceName: string = '';
+ user: System.User;
+
+ openAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceConnection.openAsync');
+ }
+
+ sendMessageAsync(message: Foundation.Collections.ValueSet): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceConnection.sendMessageAsync');
+ }
+
+ openRemoteAsync(remoteSystemConnectionRequest: System.RemoteSystems.RemoteSystemConnectionRequest): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceConnection.openRemoteAsync');
+ }
+
+ close(): void {
+ console.warn('shimmed function AppServiceConnection.close');
+ }
+
+ static sendStatelessMessageAsync(connection: AppServiceConnection, connectionRequest: System.RemoteSystems.RemoteSystemConnectionRequest, message: Foundation.Collections.ValueSet): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceConnection.sendStatelessMessageAsync');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`AppServiceConnection::addEventListener: ${name}`);
+ switch (name) {
+ case "requestreceived": // Foundation.TypedEventHandler
+ case "serviceclosed": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export enum AppServiceConnectionStatus {
+ success,
+ appNotInstalled,
+ appUnavailable,
+ appServiceUnavailable,
+ unknown,
+ remoteSystemUnavailable,
+ remoteSystemNotSupportedByApp,
+ notAuthorized,
+ }
+ export class AppServiceDeferral implements IAppServiceDeferral {
+ complete(): void {
+ console.warn('shimmed function AppServiceDeferral.complete');
+ }
+
+ }
+ export class AppServiceRequest implements IAppServiceRequest {
+ message: Foundation.Collections.ValueSet;
+
+ sendResponseAsync(message: Foundation.Collections.ValueSet): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceRequest.sendResponseAsync');
+ }
+
+ }
+ export class AppServiceRequestReceivedEventArgs implements IAppServiceRequestReceivedEventArgs {
+ request: AppServiceRequest;
+
+ getDeferral(): AppServiceDeferral {
+ throw new Error('shimmed function AppServiceRequestReceivedEventArgs.getDeferral');
+ }
+
+ }
+ export class AppServiceResponse implements IAppServiceResponse {
+ message: Foundation.Collections.ValueSet;
+ status: AppServiceResponseStatus;
+
+ }
+ export enum AppServiceResponseStatus {
+ success,
+ failure,
+ resourceLimitsExceeded,
+ unknown,
+ remoteSystemUnavailable,
+ messageSizeTooLarge,
+ }
+ export class AppServiceTriggerDetails implements IAppServiceTriggerDetails, IAppServiceTriggerDetails2, IAppServiceTriggerDetails3, IAppServiceTriggerDetails4 {
+ appServiceConnection: AppServiceConnection;
+ callerPackageFamilyName: string;
+ name: string;
+ isRemoteSystemConnection: Boolean;
+ callerRemoteConnectionToken: string;
+
+ checkCallerForCapabilityAsync(capabilityName: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AppServiceTriggerDetails.checkCallerForCapabilityAsync');
+ }
+
+ }
+ export class StatelessAppServiceResponse implements IStatelessAppServiceResponse {
+ message: Foundation.Collections.ValueSet;
+ status: StatelessAppServiceResponseStatus;
+
+ }
+ export enum StatelessAppServiceResponseStatus {
+ success,
+ appNotInstalled,
+ appUnavailable,
+ appServiceUnavailable,
+ remoteSystemUnavailable,
+ remoteSystemNotSupportedByApp,
+ notAuthorized,
+ resourceLimitsExceeded,
+ messageSizeTooLarge,
+ failure,
+ unknown,
+ }
+ }
+ export namespace Background {
+ export class ActivitySensorTrigger implements IActivitySensorTrigger, IBackgroundTrigger {
+ // constructor(reportIntervalInMilliseconds: number);
+ constructor(reportIntervalInMilliseconds: number) {}
+
+ minimumReportInterval: number;
+ reportInterval: number;
+ subscribedActivities: Devices.Sensors.ActivityType[];
+ supportedActivities: Devices.Sensors.ActivityType[];
+
+ }
+ export enum AlarmAccessStatus {
+ unspecified,
+ allowedWithWakeupCapability,
+ allowedWithoutWakeupCapability,
+ denied,
+ }
+ export class AlarmApplicationManager {
+ static requestAccessAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AlarmApplicationManager.requestAccessAsync');
+ }
+
+ static getAccessStatus(): AlarmAccessStatus {
+ throw new Error('shimmed function AlarmApplicationManager.getAccessStatus');
+ }
+
+ }
+ export class AppBroadcastTrigger implements IBackgroundTrigger, IAppBroadcastTrigger {
+ // constructor(providerKey: string);
+ constructor(providerKey: string) {}
+
+ providerInfo: AppBroadcastTriggerProviderInfo;
+
+ }
+ export class AppBroadcastTriggerProviderInfo implements IAppBroadcastTriggerProviderInfo {
+ videoKeyFrameInterval: number;
+ maxVideoWidth: number;
+ maxVideoHeight: number;
+ maxVideoBitrate: number;
+ logoResource: string;
+ displayNameResource: string;
+
+ }
+ export class ApplicationTrigger implements IApplicationTrigger, IBackgroundTrigger {
+ // constructor();
+ requestAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ApplicationTrigger.requestAsync');
+ }
+
+ requestAsync_1(__arguments: Foundation.Collections.ValueSet): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ApplicationTrigger.requestAsync_1');
+ }
+
+ }
+ export class ApplicationTriggerDetails implements IApplicationTriggerDetails {
+ __arguments: Foundation.Collections.ValueSet;
+
+ }
+ export enum ApplicationTriggerResult {
+ allowed,
+ currentlyRunning,
+ disabledByPolicy,
+ unknownError,
+ }
+ export class AppointmentStoreNotificationTrigger implements IBackgroundTrigger, IAppointmentStoreNotificationTrigger {
+ // constructor();
+ }
+ export enum BackgroundAccessRequestKind {
+ alwaysAllowed,
+ allowedSubjectToSystemPolicy,
+ }
+ export enum BackgroundAccessStatus {
+ unspecified,
+ allowedWithAlwaysOnRealTimeConnectivity,
+ allowedMayUseActiveRealTimeConnectivity,
+ denied,
+ alwaysAllowed,
+ allowedSubjectToSystemPolicy,
+ deniedBySystemPolicy,
+ deniedByUser,
+ }
+ export interface BackgroundAlarmApplicationContract {
+ }
+ export class BackgroundExecutionManager {
+ static requestAccessKindAsync(requestedAccess: BackgroundAccessRequestKind, reason: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function BackgroundExecutionManager.requestAccessKindAsync');
+ }
+
+ static requestAccessAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function BackgroundExecutionManager.requestAccessAsync');
+ }
+
+ static requestAccessAsync_1(applicationId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function BackgroundExecutionManager.requestAccessAsync_1');
+ }
+
+ static removeAccess(): void {
+ console.warn('shimmed function BackgroundExecutionManager.removeAccess');
+ }
+
+ static removeAccess_1(applicationId: string): void {
+ console.warn('shimmed function BackgroundExecutionManager.removeAccess_1');
+ }
+
+ static getAccessStatus(): BackgroundAccessStatus {
+ throw new Error('shimmed function BackgroundExecutionManager.getAccessStatus');
+ }
+
+ static getAccessStatus_1(applicationId: string): BackgroundAccessStatus {
+ throw new Error('shimmed function BackgroundExecutionManager.getAccessStatus_1');
+ }
+
+ }
+ export class BackgroundTaskBuilder implements IBackgroundTaskBuilder, IBackgroundTaskBuilder2, IBackgroundTaskBuilder3, IBackgroundTaskBuilder4 {
+ // constructor();
+ taskEntryPoint: string = 'Windows.ApplicationModel.Core.DefaultInProcBackgroundTask';
+ name: string = '';
+ cancelOnConditionLoss: Boolean = false;
+ isNetworkRequested: Boolean = false;
+ taskGroup: BackgroundTaskRegistrationGroup;
+
+ setTrigger(trigger: IBackgroundTrigger): void {
+ console.warn('shimmed function BackgroundTaskBuilder.setTrigger');
+ }
+
+ addCondition(condition: IBackgroundCondition): void {
+ console.warn('shimmed function BackgroundTaskBuilder.addCondition');
+ }
+
+ register(): BackgroundTaskRegistration {
+ throw new Error('shimmed function BackgroundTaskBuilder.register');
+ }
+
+ }
+ export type BackgroundTaskCanceledEventHandler = (reason: BackgroundTaskCancellationReason) => void;
+ export enum BackgroundTaskCancellationReason {
+ abort,
+ terminating,
+ loggingOff,
+ servicingUpdate,
+ idleTask,
+ uninstall,
+ conditionLoss,
+ systemPolicy,
+ quietHoursEntered,
+ executionTimeExceeded,
+ resourceRevocation,
+ energySaver,
+ }
+ export class BackgroundTaskCompletedEventArgs implements IBackgroundTaskCompletedEventArgs {
+ instanceId: string;
+
+ checkResult(): void {
+ console.warn('shimmed function BackgroundTaskCompletedEventArgs.checkResult');
+ }
+
+ }
+ export type BackgroundTaskCompletedEventHandler = (args: BackgroundTaskCompletedEventArgs) => void;
+ export class BackgroundTaskDeferral implements IBackgroundTaskDeferral {
+ complete(): void {
+ console.warn('shimmed function BackgroundTaskDeferral.complete');
+ }
+
+ }
+ export class BackgroundTaskProgressEventArgs implements IBackgroundTaskProgressEventArgs {
+ instanceId: string;
+ progress: number;
+
+ }
+ export type BackgroundTaskProgressEventHandler = (args: BackgroundTaskProgressEventArgs) => void;
+ export class BackgroundTaskRegistration implements IBackgroundTaskRegistration, IBackgroundTaskRegistration2, IBackgroundTaskRegistration3 {
+ name: string;
+ taskId: string;
+ trigger: IBackgroundTrigger;
+ taskGroup: BackgroundTaskRegistrationGroup;
+ static allTasks: string[] = [ ];
+ static allTaskGroups: string[] = [ ];
+
+ unregister(cancelTask: Boolean): void {
+ console.warn('shimmed function BackgroundTaskRegistration.unregister');
+ }
+
+ static getTaskGroup(groupId: string): BackgroundTaskRegistrationGroup {
+ throw new Error('shimmed function BackgroundTaskRegistration.getTaskGroup');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`BackgroundTaskRegistration::addEventListener: ${name}`);
+ switch (name) {
+ case "completed": // BackgroundTaskCompletedEventHandler
+ case "progress": // BackgroundTaskProgressEventHandler
+ break;
+ }
+
+ }
+ }
+ export class BackgroundTaskRegistrationGroup implements IBackgroundTaskRegistrationGroup {
+ // constructor(id: string);
+ // constructor(id: string, name: string);
+ constructor(id: string, name: string) {}
+
+ allTasks: string[];
+ id: string;
+ name: string;
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`BackgroundTaskRegistrationGroup::addEventListener: ${name}`);
+ switch (name) {
+ case "backgroundactivated": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export enum BackgroundTaskThrottleCounter {
+ all,
+ cpu,
+ network,
+ }
+ export class BackgroundWorkCost {
+ static currentBackgroundWorkCost: BackgroundWorkCostValue = BackgroundWorkCostValue.low;
+
+ }
+ export enum BackgroundWorkCostValue {
+ low,
+ medium,
+ high,
+ }
+ export class BluetoothLEAdvertisementPublisherTrigger implements IBluetoothLEAdvertisementPublisherTrigger, IBackgroundTrigger {
+ // constructor();
+ advertisement: Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement = null;
+
+ }
+ export class BluetoothLEAdvertisementWatcherTrigger implements IBluetoothLEAdvertisementWatcherTrigger, IBackgroundTrigger {
+ // constructor();
+ signalStrengthFilter: Devices.Bluetooth.BluetoothSignalStrengthFilter = null;
+ advertisementFilter: Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter = null;
+ maxOutOfRangeTimeout: number = 60000;
+ maxSamplingInterval: number = 25500;
+ minOutOfRangeTimeout: number = 1000;
+ minSamplingInterval: number = 1000;
+
+ }
+ export class CachedFileUpdaterTrigger implements ICachedFileUpdaterTrigger, IBackgroundTrigger {
+ // constructor();
+ }
+ export class CachedFileUpdaterTriggerDetails implements ICachedFileUpdaterTriggerDetails {
+ canRequestUserInput: Boolean;
+ updateRequest: Storage.Provider.FileUpdateRequest;
+ updateTarget: Storage.Provider.CachedFileTarget;
+
+ }
+ export class ChatMessageNotificationTrigger implements IBackgroundTrigger, IChatMessageNotificationTrigger {
+ // constructor();
+ }
+ export class ChatMessageReceivedNotificationTrigger implements IBackgroundTrigger, IChatMessageReceivedNotificationTrigger {
+ // constructor();
+ }
+ export class CommunicationBlockingAppSetAsActiveTrigger implements IBackgroundTrigger, ICommunicationBlockingAppSetAsActiveTrigger {
+ // constructor();
+ }
+ export class ContactStoreNotificationTrigger implements IBackgroundTrigger, IContactStoreNotificationTrigger {
+ // constructor();
+ }
+ export class ContentPrefetchTrigger implements IContentPrefetchTrigger, IBackgroundTrigger {
+ // constructor(waitInterval: number);
+ // constructor();
+ constructor(waitInterval: number) {}
+
+ waitInterval: number = 7200000;
+
+ }
+ export class ConversationalAgentTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class CustomSystemEventTrigger implements ICustomSystemEventTrigger, IBackgroundTrigger {
+ // constructor(triggerId: string, recurrence: CustomSystemEventTriggerRecurrence);
+ constructor(triggerId: string, recurrence: CustomSystemEventTriggerRecurrence) {}
+
+ recurrence: CustomSystemEventTriggerRecurrence;
+ triggerId: string;
+
+ }
+ export enum CustomSystemEventTriggerRecurrence {
+ once,
+ always,
+ }
+ export class DeviceConnectionChangeTrigger implements IDeviceConnectionChangeTrigger, IBackgroundTrigger {
+ maintainConnection: Boolean;
+ canMaintainConnection: Boolean;
+ deviceId: string;
+
+ static fromIdAsync(deviceId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function DeviceConnectionChangeTrigger.fromIdAsync');
+ }
+
+ }
+ export class DeviceManufacturerNotificationTrigger implements IDeviceManufacturerNotificationTrigger, IBackgroundTrigger {
+ // constructor(triggerQualifier: string, oneShot: Boolean);
+ constructor(triggerQualifier: string, oneShot: Boolean) {}
+
+ oneShot: Boolean;
+ triggerQualifier: string;
+
+ }
+ export class DeviceServicingTrigger implements IDeviceServicingTrigger, IBackgroundTrigger {
+ // constructor();
+ requestAsync(deviceId: string, expectedDuration: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function DeviceServicingTrigger.requestAsync');
+ }
+
+ requestAsync_1(deviceId: string, expectedDuration: number, __arguments: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function DeviceServicingTrigger.requestAsync_1');
+ }
+
+ }
+ export enum DeviceTriggerResult {
+ allowed,
+ deniedByUser,
+ deniedBySystem,
+ lowBattery,
+ }
+ export class DeviceUseTrigger implements IDeviceUseTrigger, IBackgroundTrigger {
+ // constructor();
+ requestAsync(deviceId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function DeviceUseTrigger.requestAsync');
+ }
+
+ requestAsync_1(deviceId: string, __arguments: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function DeviceUseTrigger.requestAsync_1');
+ }
+
+ }
+ export class DeviceWatcherTrigger implements IDeviceWatcherTrigger, IBackgroundTrigger {
+ }
+ export class EmailStoreNotificationTrigger implements IBackgroundTrigger, IEmailStoreNotificationTrigger {
+ // constructor();
+ }
+ export class GattCharacteristicNotificationTrigger implements IGattCharacteristicNotificationTrigger, IBackgroundTrigger, IGattCharacteristicNotificationTrigger2 {
+ // constructor(characteristic: Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, eventTriggeringMode: Devices.Bluetooth.Background.BluetoothEventTriggeringMode);
+ // constructor(characteristic: Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic);
+ constructor(characteristic: Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, eventTriggeringMode: Devices.Bluetooth.Background.BluetoothEventTriggeringMode) {}
+
+ characteristic: Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic;
+ eventTriggeringMode: Devices.Bluetooth.Background.BluetoothEventTriggeringMode;
+
+ }
+ export class GattServiceProviderTrigger implements IBackgroundTrigger, IGattServiceProviderTrigger {
+ advertisingParameters: Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters;
+ service: Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+ triggerId: string;
+
+ static createAsync(triggerId: string, serviceUuid: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function GattServiceProviderTrigger.createAsync');
+ }
+
+ }
+ export class GattServiceProviderTriggerResult implements IGattServiceProviderTriggerResult {
+ error: Devices.Bluetooth.BluetoothError;
+ trigger: GattServiceProviderTrigger;
+
+ }
+ export class GeovisitTrigger implements IGeovisitTrigger, IBackgroundTrigger {
+ // constructor();
+ monitoringScope: Devices.Geolocation.VisitMonitoringScope = VisitMonitoringScope.venue;
+
+ }
+ export interface IBackgroundCondition {
+ }
+ export interface IBackgroundTask {
+ run(taskInstance: IBackgroundTaskInstance): void;
+ }
+ export interface IBackgroundTaskInstance {
+ instanceId: string;
+ progress: number;
+ suspendedCount: number;
+ task: BackgroundTaskRegistration;
+ triggerDetails: any;
+ getDeferral(): BackgroundTaskDeferral;
+ }
+ export interface IBackgroundTaskInstance2 extends IBackgroundTaskInstance {
+ getThrottleCount(counter: BackgroundTaskThrottleCounter): number;
+ }
+ export interface IBackgroundTaskInstance4 extends IBackgroundTaskInstance {
+ user: System.User;
+ }
+ export interface IBackgroundTaskRegistration {
+ name: string;
+ taskId: string;
+ unregister(cancelTask: Boolean): void;
+ }
+ export interface IBackgroundTaskRegistration2 extends IBackgroundTaskRegistration {
+ trigger: IBackgroundTrigger;
+ }
+ export interface IBackgroundTaskRegistration3 extends IBackgroundTaskRegistration {
+ taskGroup: BackgroundTaskRegistrationGroup;
+ }
+ export interface IBackgroundTrigger {
+ }
+ export class LocationTrigger implements ILocationTrigger, IBackgroundTrigger {
+ // constructor(triggerType: LocationTriggerType);
+ constructor(triggerType: LocationTriggerType) {}
+
+ triggerType: LocationTriggerType;
+
+ }
+ export enum LocationTriggerType {
+ geofence,
+ }
+ export class MaintenanceTrigger implements IMaintenanceTrigger, IBackgroundTrigger {
+ // constructor(freshnessTime: number, oneShot: Boolean);
+ constructor(freshnessTime: number, oneShot: Boolean) {}
+
+ freshnessTime: number;
+ oneShot: Boolean;
+
+ }
+ export class MediaProcessingTrigger implements IMediaProcessingTrigger, IBackgroundTrigger {
+ // constructor();
+ requestAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function MediaProcessingTrigger.requestAsync');
+ }
+
+ requestAsync_1(__arguments: Foundation.Collections.ValueSet): Foundation.IAsyncOperation {
+ throw new Error('shimmed function MediaProcessingTrigger.requestAsync_1');
+ }
+
+ }
+ export enum MediaProcessingTriggerResult {
+ allowed,
+ currentlyRunning,
+ disabledByPolicy,
+ unknownError,
+ }
+ export class MobileBroadbandDeviceServiceNotificationTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class MobileBroadbandPcoDataChangeTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class MobileBroadbandPinLockStateChangeTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class MobileBroadbandRadioStateChangeTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class MobileBroadbandRegistrationStateChangeTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class NetworkOperatorDataUsageTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class NetworkOperatorHotspotAuthenticationTrigger implements INetworkOperatorHotspotAuthenticationTrigger, IBackgroundTrigger {
+ // constructor();
+ }
+ export class NetworkOperatorNotificationTrigger implements INetworkOperatorNotificationTrigger, IBackgroundTrigger {
+ // constructor(networkAccountId: string);
+ constructor(networkAccountId: string) {}
+
+ networkAccountId: string;
+
+ }
+ export class PaymentAppCanMakePaymentTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class PhoneTrigger implements IPhoneTrigger, IBackgroundTrigger {
+ // constructor(type: Calls.Background.PhoneTriggerType, oneShot: Boolean);
+ constructor(type: Calls.Background.PhoneTriggerType, oneShot: Boolean) {}
+
+ oneShot: Boolean;
+ triggerType: Calls.Background.PhoneTriggerType;
+
+ }
+ export class PushNotificationTrigger implements IBackgroundTrigger {
+ // constructor(applicationId: string);
+ // constructor();
+ constructor(applicationId: string) {}
+
+ }
+ export class RcsEndUserMessageAvailableTrigger implements IBackgroundTrigger, IRcsEndUserMessageAvailableTrigger {
+ // constructor();
+ }
+ export class RfcommConnectionTrigger implements IRfcommConnectionTrigger, IBackgroundTrigger {
+ // constructor();
+ remoteHostName: Networking.HostName;
+ protectionLevel: Networking.Sockets.SocketProtectionLevel = SocketProtectionLevel.bluetoothEncryptionWithAuthentication;
+ allowMultipleConnections: Boolean = false;
+ inboundConnection: Devices.Bluetooth.Background.RfcommInboundConnectionInformation = null;
+ outboundConnection: Devices.Bluetooth.Background.RfcommOutboundConnectionInformation = null;
+
+ }
+ export class SecondaryAuthenticationFactorAuthenticationTrigger implements ISecondaryAuthenticationFactorAuthenticationTrigger, IBackgroundTrigger {
+ // constructor();
+ }
+ export class SensorDataThresholdTrigger implements ISensorDataThresholdTrigger, IBackgroundTrigger {
+ // constructor(threshold: Devices.Sensors.ISensorDataThreshold);
+ constructor(threshold: Devices.Sensors.ISensorDataThreshold) {}
+
+ }
+ export class SmartCardTrigger implements ISmartCardTrigger, IBackgroundTrigger {
+ // constructor(triggerType: Devices.SmartCards.SmartCardTriggerType);
+ constructor(triggerType: Devices.SmartCards.SmartCardTriggerType) {}
+
+ triggerType: Devices.SmartCards.SmartCardTriggerType;
+
+ }
+ export class SmsMessageReceivedTrigger implements IBackgroundTrigger {
+ // constructor(filterRules: Devices.Sms.SmsFilterRules);
+ constructor(filterRules: Devices.Sms.SmsFilterRules) {}
+
+ }
+ export class SocketActivityTrigger implements IBackgroundTrigger, ISocketActivityTrigger {
+ // constructor();
+ isWakeFromLowPowerSupported: Boolean = true;
+
+ }
+ export class StorageLibraryChangeTrackerTrigger implements IBackgroundTrigger {
+ // constructor(tracker: Storage.StorageLibraryChangeTracker);
+ constructor(tracker: Storage.StorageLibraryChangeTracker) {}
+
+ }
+ export class StorageLibraryContentChangedTrigger implements IStorageLibraryContentChangedTrigger, IBackgroundTrigger {
+ static create(storageLibrary: Storage.StorageLibrary): StorageLibraryContentChangedTrigger {
+ throw new Error('shimmed function StorageLibraryContentChangedTrigger.create');
+ }
+
+ static createFromLibraries(storageLibraries: Foundation.Collections.IIterable): StorageLibraryContentChangedTrigger {
+ throw new Error('shimmed function StorageLibraryContentChangedTrigger.createFromLibraries');
+ }
+
+ }
+ export class SystemCondition implements ISystemCondition, IBackgroundCondition {
+ // constructor(conditionType: SystemConditionType);
+ constructor(conditionType: SystemConditionType) {}
+
+ conditionType: SystemConditionType;
+
+ }
+ export enum SystemConditionType {
+ invalid,
+ userPresent,
+ userNotPresent,
+ internetAvailable,
+ internetNotAvailable,
+ sessionConnected,
+ sessionDisconnected,
+ freeNetworkAvailable,
+ backgroundWorkCostNotHigh,
+ }
+ export class SystemTrigger implements ISystemTrigger, IBackgroundTrigger {
+ // constructor(triggerType: SystemTriggerType, oneShot: Boolean);
+ constructor(triggerType: SystemTriggerType, oneShot: Boolean) {}
+
+ oneShot: Boolean;
+ triggerType: SystemTriggerType;
+
+ }
+ export enum SystemTriggerType {
+ invalid,
+ smsReceived,
+ userPresent,
+ userAway,
+ networkStateChange,
+ controlChannelReset,
+ internetAvailable,
+ sessionConnected,
+ servicingComplete,
+ lockScreenApplicationAdded,
+ lockScreenApplicationRemoved,
+ timeZoneChange,
+ onlineIdConnectedStateChange,
+ backgroundWorkCostChange,
+ powerStateChange,
+ defaultSignInAccountChange,
+ }
+ export class TetheringEntitlementCheckTrigger implements IBackgroundTrigger {
+ // constructor();
+ }
+ export class TimeTrigger implements ITimeTrigger, IBackgroundTrigger {
+ // constructor(freshnessTime: number, oneShot: Boolean);
+ constructor(freshnessTime: number, oneShot: Boolean) {}
+
+ freshnessTime: number;
+ oneShot: Boolean;
+
+ }
+ export class ToastNotificationActionTrigger implements IBackgroundTrigger {
+ // constructor(applicationId: string);
+ // constructor();
+ constructor(applicationId: string) {}
+
+ }
+ export class ToastNotificationHistoryChangedTrigger implements IBackgroundTrigger {
+ // constructor(applicationId: string);
+ // constructor();
+ constructor(applicationId: string) {}
+
+ }
+ export class UserNotificationChangedTrigger implements IBackgroundTrigger {
+ // constructor(notificationKinds: UI.Notifications.NotificationKinds);
+ constructor(notificationKinds: UI.Notifications.NotificationKinds) {}
+
+ }
+ }
+ export namespace Calls {
+ export namespace Background {
+ export interface CallsBackgroundContract {
+ }
+ export enum PhoneCallBlockedReason {
+ inCallBlockingList,
+ privateNumber,
+ unknownNumber,
+ }
+ export class PhoneCallBlockedTriggerDetails implements IPhoneCallBlockedTriggerDetails {
+ callBlockedReason: PhoneCallBlockedReason;
+ lineId: string;
+ phoneNumber: string;
+
+ }
+ export class PhoneCallOriginDataRequestTriggerDetails implements IPhoneCallOriginDataRequestTriggerDetails {
+ phoneNumber: string;
+ requestId: string;
+
+ }
+ export enum PhoneIncomingCallDismissedReason {
+ unknown,
+ callRejected,
+ textReply,
+ connectionLost,
+ }
+ export class PhoneIncomingCallDismissedTriggerDetails implements IPhoneIncomingCallDismissedTriggerDetails {
+ dismissalTime: Date;
+ displayName: string;
+ lineId: string;
+ phoneNumber: string;
+ reason: PhoneIncomingCallDismissedReason;
+ textReplyMessage: string;
+
+ }
+ export class PhoneLineChangedTriggerDetails implements IPhoneLineChangedTriggerDetails {
+ changeType: PhoneLineChangeKind;
+ lineId: string;
+
+ hasLinePropertyChanged(lineProperty: PhoneLineProperties): Boolean {
+ throw new Error('shimmed function PhoneLineChangedTriggerDetails.hasLinePropertyChanged');
+ }
+
+ }
+ export enum PhoneLineChangeKind {
+ added,
+ removed,
+ propertiesChanged,
+ }
+ export enum PhoneLineProperties {
+ none,
+ brandingOptions,
+ canDial,
+ cellularDetails = 4,
+ displayColor = 8,
+ displayName = 16,
+ networkName = 32,
+ networkState = 64,
+ transport = 128,
+ voicemail = 256,
+ }
+ export class PhoneNewVoicemailMessageTriggerDetails implements IPhoneNewVoicemailMessageTriggerDetails {
+ lineId: string;
+ operatorMessage: string;
+ voicemailCount: number;
+
+ }
+ export enum PhoneTriggerType {
+ newVoicemailMessage,
+ callHistoryChanged,
+ lineChanged,
+ airplaneModeDisabledForEmergencyCall,
+ callOriginDataRequest,
+ callBlocked,
+ incomingCallDismissed,
+ }
+ }
+ export class CallAnswerEventArgs implements ICallAnswerEventArgs {
+ acceptedMedia: VoipPhoneCallMedia;
+
+ }
+ export class CallRejectEventArgs implements ICallRejectEventArgs {
+ rejectReason: VoipPhoneCallRejectReason;
+
+ }
+ export interface CallsPhoneContract {
+ }
+ export class CallStateChangeEventArgs implements ICallStateChangeEventArgs {
+ state: VoipPhoneCallState;
+
+ }
+ export interface CallsVoipContract {
+ }
+ export enum CellularDtmfMode {
+ continuous,
+ burst,
+ }
+ export interface LockScreenCallContract {
+ }
+ export class LockScreenCallEndCallDeferral implements ILockScreenCallEndCallDeferral {
+ complete(): void {
+ console.warn('shimmed function LockScreenCallEndCallDeferral.complete');
+ }
+
+ }
+ export class LockScreenCallEndRequestedEventArgs implements ILockScreenCallEndRequestedEventArgs {
+ deadline: Date;
+
+ getDeferral(): LockScreenCallEndCallDeferral {
+ throw new Error('shimmed function LockScreenCallEndRequestedEventArgs.getDeferral');
+ }
+
+ }
+ export class LockScreenCallUI implements ILockScreenCallUI {
+ callTitle: string;
+
+ dismiss(): void {
+ console.warn('shimmed function LockScreenCallUI.dismiss');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`LockScreenCallUI::addEventListener: ${name}`);
+ switch (name) {
+ case "closed": // Foundation.TypedEventHandler
+ case "endrequested": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class MuteChangeEventArgs implements IMuteChangeEventArgs {
+ muted: Boolean;
+
+ }
+ export enum PhoneAudioRoutingEndpoint {
+ default,
+ bluetooth,
+ speakerphone,
+ }
+ export class PhoneCallBlocking {
+ static blockUnknownNumbers: Boolean;
+ static blockPrivateNumbers: Boolean;
+
+ static setCallBlockingListAsync(phoneNumberList: Foundation.Collections.IIterable): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallBlocking.setCallBlockingListAsync');
+ }
+
+ }
+ export class PhoneCallHistoryEntry implements IPhoneCallHistoryEntry {
+ // constructor();
+ media: PhoneCallHistoryEntryMedia = PhoneCallHistoryEntryMedia.audio;
+ isMissed: Boolean = false;
+ isIncoming: Boolean = false;
+ isCallerIdBlocked: Boolean = false;
+ isSeen: Boolean = false;
+ duration: number | null;
+ isEmergency: Boolean = false;
+ isSuppressed: Boolean = false;
+ startTime: Date = new Date(-11644473600000);
+ sourceIdKind: PhoneCallHistorySourceIdKind = PhoneCallHistorySourceIdKind.packageFamilyName;
+ address: PhoneCallHistoryEntryAddress;
+ sourceId: string = '';
+ remoteId: string = '';
+ otherAppReadAccess: PhoneCallHistoryEntryOtherAppReadAccess = PhoneCallHistoryEntryOtherAppReadAccess.full;
+ isRinging: Boolean = false;
+ isVoicemail: Boolean = false;
+ id: string = '';
+ sourceDisplayName: string = '';
+
+ }
+ export class PhoneCallHistoryEntryAddress implements IPhoneCallHistoryEntryAddress {
+ // constructor(rawAddress: string, rawAddressKind: PhoneCallHistoryEntryRawAddressKind);
+ // constructor();
+ constructor(rawAddress: string, rawAddressKind: PhoneCallHistoryEntryRawAddressKind) {}
+
+ rawAddressKind: PhoneCallHistoryEntryRawAddressKind = PhoneCallHistoryEntryRawAddressKind.custom;
+ rawAddress: string = '';
+ displayName: string = '';
+ contactId: string = '';
+
+ }
+ export enum PhoneCallHistoryEntryMedia {
+ audio,
+ video,
+ }
+ export enum PhoneCallHistoryEntryOtherAppReadAccess {
+ full,
+ systemOnly,
+ }
+ export enum PhoneCallHistoryEntryQueryDesiredMedia {
+ none,
+ audio,
+ video,
+ all = 4294967295,
+ }
+ export class PhoneCallHistoryEntryQueryOptions implements IPhoneCallHistoryEntryQueryOptions {
+ // constructor();
+ desiredMedia: PhoneCallHistoryEntryQueryDesiredMedia = PhoneCallHistoryEntryQueryDesiredMedia.all;
+ sourceIds: string[] = [ ];
+
+ }
+ export enum PhoneCallHistoryEntryRawAddressKind {
+ phoneNumber,
+ custom,
+ }
+ export class PhoneCallHistoryEntryReader implements IPhoneCallHistoryEntryReader {
+ readBatchAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallHistoryEntryReader.readBatchAsync');
+ }
+
+ }
+ export class PhoneCallHistoryManager {
+ static getForUser(user: System.User): PhoneCallHistoryManagerForUser {
+ throw new Error('shimmed function PhoneCallHistoryManager.getForUser');
+ }
+
+ static requestStoreAsync(accessType: PhoneCallHistoryStoreAccessType): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallHistoryManager.requestStoreAsync');
+ }
+
+ }
+ export class PhoneCallHistoryManagerForUser implements IPhoneCallHistoryManagerForUser {
+ user: System.User;
+
+ requestStoreAsync(accessType: PhoneCallHistoryStoreAccessType): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallHistoryManagerForUser.requestStoreAsync');
+ }
+
+ }
+ export enum PhoneCallHistorySourceIdKind {
+ cellularPhoneLineId,
+ packageFamilyName,
+ }
+ export class PhoneCallHistoryStore implements IPhoneCallHistoryStore {
+ getEntryAsync(callHistoryEntryId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallHistoryStore.getEntryAsync');
+ }
+
+ getEntryReader(): PhoneCallHistoryEntryReader {
+ throw new Error('shimmed function PhoneCallHistoryStore.getEntryReader');
+ }
+
+ getEntryReader_1(queryOptions: PhoneCallHistoryEntryQueryOptions): PhoneCallHistoryEntryReader {
+ throw new Error('shimmed function PhoneCallHistoryStore.getEntryReader_1');
+ }
+
+ saveEntryAsync(callHistoryEntry: PhoneCallHistoryEntry): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.saveEntryAsync');
+ }
+
+ deleteEntryAsync(callHistoryEntry: PhoneCallHistoryEntry): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.deleteEntryAsync');
+ }
+
+ deleteEntriesAsync(callHistoryEntries: Foundation.Collections.IIterable): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.deleteEntriesAsync');
+ }
+
+ markEntryAsSeenAsync(callHistoryEntry: PhoneCallHistoryEntry): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.markEntryAsSeenAsync');
+ }
+
+ markEntriesAsSeenAsync(callHistoryEntries: Foundation.Collections.IIterable): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.markEntriesAsSeenAsync');
+ }
+
+ getUnseenCountAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallHistoryStore.getUnseenCountAsync');
+ }
+
+ markAllAsSeenAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.markAllAsSeenAsync');
+ }
+
+ getSourcesUnseenCountAsync(sourceIds: Foundation.Collections.IIterable): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallHistoryStore.getSourcesUnseenCountAsync');
+ }
+
+ markSourcesAsSeenAsync(sourceIds: Foundation.Collections.IIterable): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneCallHistoryStore.markSourcesAsSeenAsync');
+ }
+
+ }
+ export enum PhoneCallHistoryStoreAccessType {
+ appEntriesReadWrite,
+ allEntriesLimitedReadWrite,
+ allEntriesReadWrite,
+ }
+ export class PhoneCallManager {
+ static isCallActive: Boolean = false;
+ static isCallIncoming: Boolean = false;
+
+ static showPhoneCallSettingsUI(): void {
+ console.warn('shimmed function PhoneCallManager.showPhoneCallSettingsUI');
+ }
+
+ static requestStoreAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallManager.requestStoreAsync');
+ }
+
+ static showPhoneCallUI(phoneNumber: string, displayName: string): void {
+ console.warn('shimmed function PhoneCallManager.showPhoneCallUI');
+ }
+
+ static addEventListener(name: string, handler: Function) {
+ console.warn(`PhoneCallManager::addEventListener: ${name}`);
+ switch (name) {
+ case "callstatechanged": // /* System.EventHandler`1[[System.Object, System.Private.CoreLib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]] */ any
+ break;
+ }
+
+ }
+ }
+ export enum PhoneCallMedia {
+ audio,
+ audioAndVideo,
+ audioAndRealTimeText,
+ }
+ export class PhoneCallStore implements IPhoneCallStore {
+ isEmergencyPhoneNumberAsync(number: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallStore.isEmergencyPhoneNumberAsync');
+ }
+
+ getDefaultLineAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallStore.getDefaultLineAsync');
+ }
+
+ requestLineWatcher(): PhoneLineWatcher {
+ throw new Error('shimmed function PhoneCallStore.requestLineWatcher');
+ }
+
+ }
+ export class PhoneCallVideoCapabilities implements IPhoneCallVideoCapabilities {
+ isVideoCallingCapable: Boolean;
+
+ }
+ export class PhoneCallVideoCapabilitiesManager {
+ static getCapabilitiesAsync(phoneNumber: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallVideoCapabilitiesManager.getCapabilitiesAsync');
+ }
+
+ }
+ export class PhoneDialOptions implements IPhoneDialOptions {
+ // constructor();
+ number: string = '';
+ media: PhoneCallMedia = PhoneCallMedia.audio;
+ displayName: string = '';
+ contactPhone: Contacts.ContactPhone;
+ contact: Contacts.Contact;
+ audioEndpoint: PhoneAudioRoutingEndpoint = PhoneAudioRoutingEndpoint.default;
+
+ }
+ export class PhoneLine implements IPhoneLine, IPhoneLine2 {
+ canDial: Boolean;
+ cellularDetails: PhoneLineCellularDetails;
+ displayColor: UI.Color;
+ displayName: string;
+ id: string;
+ lineConfiguration: PhoneLineConfiguration;
+ networkName: string;
+ networkState: PhoneNetworkState;
+ supportsTile: Boolean;
+ transport: PhoneLineTransport;
+ videoCallingCapabilities: PhoneCallVideoCapabilities;
+ voicemail: PhoneVoicemail;
+ transportDeviceId: string;
+
+ isImmediateDialNumberAsync(number: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneLine.isImmediateDialNumberAsync');
+ }
+
+ dial(number: string, displayName: string): void {
+ console.warn('shimmed function PhoneLine.dial');
+ }
+
+ dialWithOptions(options: PhoneDialOptions): void {
+ console.warn('shimmed function PhoneLine.dialWithOptions');
+ }
+
+ enableTextReply(value: Boolean): void {
+ console.warn('shimmed function PhoneLine.enableTextReply');
+ }
+
+ static fromIdAsync(lineId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneLine.fromIdAsync');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`PhoneLine::addEventListener: ${name}`);
+ switch (name) {
+ case "linechanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class PhoneLineCellularDetails implements IPhoneLineCellularDetails {
+ isModemOn: Boolean;
+ registrationRejectCode: number;
+ simSlotIndex: number;
+ simState: PhoneSimState;
+
+ getNetworkOperatorDisplayText(location: PhoneLineNetworkOperatorDisplayTextLocation): string {
+ throw new Error('shimmed function PhoneLineCellularDetails.getNetworkOperatorDisplayText');
+ }
+
+ }
+ export class PhoneLineConfiguration implements IPhoneLineConfiguration {
+ extendedProperties: string[];
+ isVideoCallingEnabled: Boolean;
+
+ }
+ export enum PhoneLineNetworkOperatorDisplayTextLocation {
+ default,
+ tile,
+ dialer,
+ inCallUI,
+ }
+ export enum PhoneLineTransport {
+ cellular,
+ voipApp,
+ bluetooth,
+ }
+ export class PhoneLineTransportDevice implements IPhoneLineTransportDevice {
+ deviceId: string;
+ transport: PhoneLineTransport;
+
+ requestAccessAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneLineTransportDevice.requestAccessAsync');
+ }
+
+ registerApp(): void {
+ console.warn('shimmed function PhoneLineTransportDevice.registerApp');
+ }
+
+ registerAppForUser(user: System.User): void {
+ console.warn('shimmed function PhoneLineTransportDevice.registerAppForUser');
+ }
+
+ unregisterApp(): void {
+ console.warn('shimmed function PhoneLineTransportDevice.unregisterApp');
+ }
+
+ unregisterAppForUser(user: System.User): void {
+ console.warn('shimmed function PhoneLineTransportDevice.unregisterAppForUser');
+ }
+
+ isRegistered(): Boolean {
+ throw new Error('shimmed function PhoneLineTransportDevice.isRegistered');
+ }
+
+ connect(): Boolean {
+ throw new Error('shimmed function PhoneLineTransportDevice.connect');
+ }
+
+ connectAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneLineTransportDevice.connectAsync');
+ }
+
+ static fromId(id: string): PhoneLineTransportDevice {
+ throw new Error('shimmed function PhoneLineTransportDevice.fromId');
+ }
+
+ static getDeviceSelector(): string {
+ throw new Error('shimmed function PhoneLineTransportDevice.getDeviceSelector');
+ }
+
+ static getDeviceSelector_1(transport: PhoneLineTransport): string {
+ throw new Error('shimmed function PhoneLineTransportDevice.getDeviceSelector_1');
+ }
+
+ }
+ export class PhoneLineWatcher implements IPhoneLineWatcher {
+ status: PhoneLineWatcherStatus;
+
+ start(): void {
+ console.warn('shimmed function PhoneLineWatcher.start');
+ }
+
+ stop(): void {
+ console.warn('shimmed function PhoneLineWatcher.stop');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`PhoneLineWatcher::addEventListener: ${name}`);
+ switch (name) {
+ case "enumerationcompleted": // Foundation.TypedEventHandler
+ case "lineadded": // Foundation.TypedEventHandler
+ case "lineremoved": // Foundation.TypedEventHandler
+ case "lineupdated": // Foundation.TypedEventHandler
+ case "stopped": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class PhoneLineWatcherEventArgs implements IPhoneLineWatcherEventArgs {
+ lineId: string;
+
+ }
+ export enum PhoneLineWatcherStatus {
+ created,
+ started,
+ enumerationCompleted,
+ stopped,
+ }
+ export enum PhoneNetworkState {
+ unknown,
+ noSignal,
+ deregistered,
+ denied,
+ searching,
+ home,
+ roamingInternational,
+ roamingDomestic,
+ }
+ export enum PhoneSimState {
+ unknown,
+ pinNotRequired,
+ pinUnlocked,
+ pinLocked,
+ pukLocked,
+ notInserted,
+ invalid,
+ disabled,
+ }
+ export class PhoneVoicemail implements IPhoneVoicemail {
+ messageCount: number;
+ number: string;
+ type: PhoneVoicemailType;
+
+ dialVoicemailAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function PhoneVoicemail.dialVoicemailAsync');
+ }
+
+ }
+ export enum PhoneVoicemailType {
+ none,
+ traditional,
+ visual,
+ }
+ export namespace Provider {
+ export class PhoneCallOrigin implements IPhoneCallOrigin, IPhoneCallOrigin2, IPhoneCallOrigin3 {
+ // constructor();
+ location: string = '';
+ categoryDescription: string = '';
+ category: string = '';
+ displayName: string = '';
+ displayPicture: Storage.StorageFile;
+
+ }
+ export class PhoneCallOriginManager {
+ static isCurrentAppActiveCallOriginApp: Boolean;
+ static isSupported: Boolean;
+
+ static requestSetAsActiveCallOriginAppAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function PhoneCallOriginManager.requestSetAsActiveCallOriginAppAsync');
+ }
+
+ static showPhoneCallOriginSettingsUI(): void {
+ console.warn('shimmed function PhoneCallOriginManager.showPhoneCallOriginSettingsUI');
+ }
+
+ static setCallOrigin(requestId: string, callOrigin: PhoneCallOrigin): void {
+ console.warn('shimmed function PhoneCallOriginManager.setCallOrigin');
+ }
+
+ }
+ }
+ export class VoipCallCoordinator implements IVoipCallCoordinator, IVoipCallCoordinator2, IVoipCallCoordinator3, IVoipCallCoordinator4 {
+ reserveCallResourcesAsync(taskEntryPoint: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function VoipCallCoordinator.reserveCallResourcesAsync');
+ }
+
+ requestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Foundation.Uri, serviceName: string, brandingImage: Foundation.Uri, callDetails: string, ringtone: Foundation.Uri, media: VoipPhoneCallMedia, ringTimeout: number): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.requestNewIncomingCall');
+ }
+
+ requestNewOutgoingCall(context: string, contactName: string, serviceName: string, media: VoipPhoneCallMedia): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.requestNewOutgoingCall');
+ }
+
+ notifyMuted(): void {
+ console.warn('shimmed function VoipCallCoordinator.notifyMuted');
+ }
+
+ notifyUnmuted(): void {
+ console.warn('shimmed function VoipCallCoordinator.notifyUnmuted');
+ }
+
+ requestOutgoingUpgradeToVideoCall(callUpgradeGuid: string, context: string, contactName: string, serviceName: string): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.requestOutgoingUpgradeToVideoCall');
+ }
+
+ requestIncomingUpgradeToVideoCall(context: string, contactName: string, contactNumber: string, contactImage: Foundation.Uri, serviceName: string, brandingImage: Foundation.Uri, callDetails: string, ringtone: Foundation.Uri, ringTimeout: number): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.requestIncomingUpgradeToVideoCall');
+ }
+
+ terminateCellularCall(callUpgradeGuid: string): void {
+ console.warn('shimmed function VoipCallCoordinator.terminateCellularCall');
+ }
+
+ cancelUpgrade(callUpgradeGuid: string): void {
+ console.warn('shimmed function VoipCallCoordinator.cancelUpgrade');
+ }
+
+ setupNewAcceptedCall(context: string, contactName: string, contactNumber: string, serviceName: string, media: VoipPhoneCallMedia): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.setupNewAcceptedCall');
+ }
+
+ requestNewAppInitiatedCall(context: string, contactName: string, contactNumber: string, serviceName: string, media: VoipPhoneCallMedia): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.requestNewAppInitiatedCall');
+ }
+
+ requestNewIncomingCall_1(context: string, contactName: string, contactNumber: string, contactImage: Foundation.Uri, serviceName: string, brandingImage: Foundation.Uri, callDetails: string, ringtone: Foundation.Uri, media: VoipPhoneCallMedia, ringTimeout: number, contactRemoteId: string): VoipPhoneCall {
+ throw new Error('shimmed function VoipCallCoordinator.requestNewIncomingCall_1');
+ }
+
+ reserveCallResourcesAsync_1(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function VoipCallCoordinator.reserveCallResourcesAsync_1');
+ }
+
+ static getDefault(): VoipCallCoordinator {
+ throw new Error('shimmed function VoipCallCoordinator.getDefault');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`VoipCallCoordinator::addEventListener: ${name}`);
+ switch (name) {
+ case "mutestatechanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class VoipPhoneCall implements IVoipPhoneCall, IVoipPhoneCall2, IVoipPhoneCall3 {
+ startTime: Date;
+ contactName: string;
+ callMedia: VoipPhoneCallMedia;
+
+ notifyCallHeld(): void {
+ console.warn('shimmed function VoipPhoneCall.notifyCallHeld');
+ }
+
+ notifyCallActive(): void {
+ console.warn('shimmed function VoipPhoneCall.notifyCallActive');
+ }
+
+ notifyCallEnded(): void {
+ console.warn('shimmed function VoipPhoneCall.notifyCallEnded');
+ }
+
+ notifyCallReady(): void {
+ console.warn('shimmed function VoipPhoneCall.notifyCallReady');
+ }
+
+ tryShowAppUI(): void {
+ console.warn('shimmed function VoipPhoneCall.tryShowAppUI');
+ }
+
+ notifyCallAccepted(media: VoipPhoneCallMedia): void {
+ console.warn('shimmed function VoipPhoneCall.notifyCallAccepted');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`VoipPhoneCall::addEventListener: ${name}`);
+ switch (name) {
+ case "answerrequested": // Foundation.TypedEventHandler
+ case "endrequested": // Foundation.TypedEventHandler
+ case "holdrequested": // Foundation.TypedEventHandler
+ case "rejectrequested": // Foundation.TypedEventHandler
+ case "resumerequested": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export enum VoipPhoneCallMedia {
+ none,
+ audio,
+ video,
+ }
+ export enum VoipPhoneCallRejectReason {
+ userIgnored,
+ timedOut,
+ otherIncomingCall,
+ emergencyCallExists,
+ invalidCallState,
+ }
+ export enum VoipPhoneCallResourceReservationStatus {
+ success,
+ resourcesNotAvailable,
+ }
+ export enum VoipPhoneCallState {
+ ended,
+ held,
+ active,
+ incoming,
+ outgoing,
+ }
+ }
+ export class CameraApplicationManager {
+ static showInstalledApplicationsUI(): void {
+ console.warn('shimmed function CameraApplicationManager.showInstalledApplicationsUI');
+ }
+
+ }
+ export namespace Chat {
+ export class ChatCapabilities implements IChatCapabilities {
+ isChatCapable: Boolean;
+ isFileTransferCapable: Boolean;
+ isGeoLocationPushCapable: Boolean;
+ isIntegratedMessagingCapable: Boolean;
+ isOnline: Boolean;
+
+ }
+ export class ChatCapabilitiesManager {
+ static getCachedCapabilitiesAsync(address: string, transportId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatCapabilitiesManager.getCachedCapabilitiesAsync');
+ }
+
+ static getCapabilitiesFromNetworkAsync(address: string, transportId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatCapabilitiesManager.getCapabilitiesFromNetworkAsync');
+ }
+
+ static getCachedCapabilitiesAsync_1(address: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatCapabilitiesManager.getCachedCapabilitiesAsync_1');
+ }
+
+ static getCapabilitiesFromNetworkAsync_1(address: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatCapabilitiesManager.getCapabilitiesFromNetworkAsync_1');
+ }
+
+ }
+ export class ChatConversation implements IChatConversation, IChatConversation2, IChatItem {
+ subject: string;
+ isConversationMuted: Boolean;
+ hasUnreadMessages: Boolean;
+ id: string;
+ mostRecentMessageId: string;
+ participants: string[];
+ threadingInfo: ChatConversationThreadingInfo;
+ canModifyParticipants: Boolean;
+ itemKind: ChatItemKind;
+
+ deleteAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatConversation.deleteAsync');
+ }
+
+ getMessageReader(): ChatMessageReader {
+ throw new Error('shimmed function ChatConversation.getMessageReader');
+ }
+
+ markMessagesAsReadAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatConversation.markMessagesAsReadAsync');
+ }
+
+ markMessagesAsReadAsync_1(value: Date): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatConversation.markMessagesAsReadAsync_1');
+ }
+
+ saveAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatConversation.saveAsync');
+ }
+
+ notifyLocalParticipantComposing(transportId: string, participantAddress: string, isComposing: Boolean): void {
+ console.warn('shimmed function ChatConversation.notifyLocalParticipantComposing');
+ }
+
+ notifyRemoteParticipantComposing(transportId: string, participantAddress: string, isComposing: Boolean): void {
+ console.warn('shimmed function ChatConversation.notifyRemoteParticipantComposing');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`ChatConversation::addEventListener: ${name}`);
+ switch (name) {
+ case "remoteparticipantcomposingchanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class ChatConversationReader implements IChatConversationReader {
+ readBatchAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatConversationReader.readBatchAsync');
+ }
+
+ readBatchAsync_1(count: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatConversationReader.readBatchAsync_1');
+ }
+
+ }
+ export class ChatConversationThreadingInfo implements IChatConversationThreadingInfo {
+ // constructor();
+ kind: ChatConversationThreadingKind = ChatConversationThreadingKind.participants;
+ custom: string = '';
+ conversationId: string = '';
+ contactId: string = '';
+ participants: string[] = [ ];
+
+ }
+ export enum ChatConversationThreadingKind {
+ participants,
+ contactId,
+ conversationId,
+ custom,
+ }
+ export enum ChatItemKind {
+ message,
+ conversation,
+ }
+ export class ChatMessage implements IChatMessage, IChatMessage2, IChatMessage3, IChatMessage4, IChatItem {
+ // constructor();
+ itemKind: ChatItemKind = ChatItemKind.message;
+ isIncoming: Boolean = false;
+ isForwardingDisabled: Boolean = false;
+ transportId: string = '0';
+ status: ChatMessageStatus = ChatMessageStatus.draft;
+ from: string = '';
+ body: string = '';
+ subject: string = '';
+ isRead: Boolean = true;
+ networkTimestamp: Date = new Date(1616785454317.62);
+ localTimestamp: Date = new Date(1616785454317.62);
+ recipientSendStatuses: string[] = [ ];
+ recipients: string[] = [ ];
+ transportFriendlyName: string = '';
+ attachments: ChatMessageAttachment[] = [ ];
+ id: string = '';
+ isSeen: Boolean = false;
+ messageKind: ChatMessageKind = ChatMessageKind.standard;
+ isReceivedDuringQuietHours: Boolean;
+ isAutoReply: Boolean;
+ estimatedDownloadSize: number;
+ threadingInfo: ChatConversationThreadingInfo;
+ shouldSuppressNotification: Boolean;
+ remoteId: string;
+ messageOperatorKind: ChatMessageOperatorKind = ChatMessageOperatorKind.unspecified;
+ isReplyDisabled: Boolean = false;
+ isSimMessage: Boolean;
+ recipientsDeliveryInfos: ChatRecipientDeliveryInfo[] = [ ];
+ syncId: string = '';
+
+ }
+ export class ChatMessageAttachment implements IChatMessageAttachment, IChatMessageAttachment2 {
+ // constructor(mimeType: string, dataStreamReference: Storage.Streams.IRandomAccessStreamReference);
+ constructor(mimeType: string, dataStreamReference: Storage.Streams.IRandomAccessStreamReference) {}
+
+ text: string;
+ mimeType: string;
+ groupId: number;
+ dataStreamReference: Storage.Streams.IRandomAccessStreamReference;
+ transferProgress: number;
+ thumbnail: Storage.Streams.IRandomAccessStreamReference;
+ originalFileName: string;
+
+ }
+ export class ChatMessageBlocking {
+ static markMessageAsBlockedAsync(localChatMessageId: string, blocked: Boolean): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageBlocking.markMessageAsBlockedAsync');
+ }
+
+ }
+ export class ChatMessageChange implements IChatMessageChange {
+ changeType: ChatMessageChangeType;
+ message: ChatMessage;
+
+ }
+ export class ChatMessageChangedDeferral implements IChatMessageChangedDeferral {
+ complete(): void {
+ console.warn('shimmed function ChatMessageChangedDeferral.complete');
+ }
+
+ }
+ export class ChatMessageChangedEventArgs implements IChatMessageChangedEventArgs {
+ getDeferral(): ChatMessageChangedDeferral {
+ throw new Error('shimmed function ChatMessageChangedEventArgs.getDeferral');
+ }
+
+ }
+ export class ChatMessageChangeReader implements IChatMessageChangeReader {
+ acceptChanges(): void {
+ console.warn('shimmed function ChatMessageChangeReader.acceptChanges');
+ }
+
+ acceptChangesThrough(lastChangeToAcknowledge: ChatMessageChange): void {
+ console.warn('shimmed function ChatMessageChangeReader.acceptChangesThrough');
+ }
+
+ readBatchAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageChangeReader.readBatchAsync');
+ }
+
+ }
+ export class ChatMessageChangeTracker implements IChatMessageChangeTracker {
+ enable(): void {
+ console.warn('shimmed function ChatMessageChangeTracker.enable');
+ }
+
+ getChangeReader(): ChatMessageChangeReader {
+ throw new Error('shimmed function ChatMessageChangeTracker.getChangeReader');
+ }
+
+ reset(): void {
+ console.warn('shimmed function ChatMessageChangeTracker.reset');
+ }
+
+ }
+ export enum ChatMessageChangeType {
+ messageCreated,
+ messageModified,
+ messageDeleted,
+ changeTrackingLost,
+ }
+ export enum ChatMessageKind {
+ standard,
+ fileTransferRequest,
+ transportCustom,
+ joinedConversation,
+ leftConversation,
+ otherParticipantJoinedConversation,
+ otherParticipantLeftConversation,
+ }
+ export class ChatMessageManager {
+ static requestSyncManagerAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageManager.requestSyncManagerAsync');
+ }
+
+ static registerTransportAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageManager.registerTransportAsync');
+ }
+
+ static getTransportAsync(transportId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageManager.getTransportAsync');
+ }
+
+ static getTransportsAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageManager.getTransportsAsync');
+ }
+
+ static requestStoreAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageManager.requestStoreAsync');
+ }
+
+ static showComposeSmsMessageAsync(message: ChatMessage): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageManager.showComposeSmsMessageAsync');
+ }
+
+ static showSmsSettings(): void {
+ console.warn('shimmed function ChatMessageManager.showSmsSettings');
+ }
+
+ }
+ export class ChatMessageNotificationTriggerDetails implements IChatMessageNotificationTriggerDetails, IChatMessageNotificationTriggerDetails2 {
+ chatMessage: ChatMessage;
+ shouldDisplayToast: Boolean;
+ shouldUpdateActionCenter: Boolean;
+ shouldUpdateBadge: Boolean;
+ shouldUpdateDetailText: Boolean;
+
+ }
+ export enum ChatMessageOperatorKind {
+ unspecified,
+ sms,
+ mms,
+ rcs,
+ }
+ export class ChatMessageReader implements IChatMessageReader, IChatMessageReader2 {
+ readBatchAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageReader.readBatchAsync');
+ }
+
+ readBatchAsync_1(count: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageReader.readBatchAsync_1');
+ }
+
+ }
+ export enum ChatMessageStatus {
+ draft,
+ sending,
+ sent,
+ sendRetryNeeded,
+ sendFailed,
+ received,
+ receiveDownloadNeeded,
+ receiveDownloadFailed,
+ receiveDownloading,
+ deleted,
+ declined,
+ cancelled,
+ recalled,
+ receiveRetryNeeded,
+ }
+ export class ChatMessageStore implements IChatMessageStore, IChatMessageStore2, IChatMessageStore3 {
+ changeTracker: ChatMessageChangeTracker;
+
+ deleteMessageAsync(localMessageId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.deleteMessageAsync');
+ }
+
+ downloadMessageAsync(localChatMessageId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.downloadMessageAsync');
+ }
+
+ getMessageAsync(localChatMessageId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getMessageAsync');
+ }
+
+ getMessageReader(): ChatMessageReader {
+ throw new Error('shimmed function ChatMessageStore.getMessageReader');
+ }
+
+ getMessageReader_1(recentTimeLimit: number): ChatMessageReader {
+ throw new Error('shimmed function ChatMessageStore.getMessageReader_1');
+ }
+
+ markMessageReadAsync(localChatMessageId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.markMessageReadAsync');
+ }
+
+ retrySendMessageAsync(localChatMessageId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.retrySendMessageAsync');
+ }
+
+ sendMessageAsync(chatMessage: ChatMessage): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.sendMessageAsync');
+ }
+
+ validateMessage(chatMessage: ChatMessage): ChatMessageValidationResult {
+ throw new Error('shimmed function ChatMessageStore.validateMessage');
+ }
+
+ forwardMessageAsync(localChatMessageId: string, addresses: Foundation.Collections.IIterable): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.forwardMessageAsync');
+ }
+
+ getConversationAsync(conversationId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getConversationAsync');
+ }
+
+ getConversationAsync_1(conversationId: string, transportIds: Foundation.Collections.IIterable): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getConversationAsync_1');
+ }
+
+ getConversationFromThreadingInfoAsync(threadingInfo: ChatConversationThreadingInfo): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getConversationFromThreadingInfoAsync');
+ }
+
+ getConversationReader(): ChatConversationReader {
+ throw new Error('shimmed function ChatMessageStore.getConversationReader');
+ }
+
+ getConversationReader_1(transportIds: Foundation.Collections.IIterable): ChatConversationReader {
+ throw new Error('shimmed function ChatMessageStore.getConversationReader_1');
+ }
+
+ getMessageByRemoteIdAsync(transportId: string, remoteId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getMessageByRemoteIdAsync');
+ }
+
+ getUnseenCountAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getUnseenCountAsync');
+ }
+
+ getUnseenCountAsync_1(transportIds: Foundation.Collections.IIterable): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getUnseenCountAsync_1');
+ }
+
+ markAsSeenAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.markAsSeenAsync');
+ }
+
+ markAsSeenAsync_1(transportIds: Foundation.Collections.IIterable): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.markAsSeenAsync_1');
+ }
+
+ getSearchReader(value: ChatQueryOptions): ChatSearchReader {
+ throw new Error('shimmed function ChatMessageStore.getSearchReader');
+ }
+
+ saveMessageAsync(chatMessage: ChatMessage): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageStore.saveMessageAsync');
+ }
+
+ tryCancelDownloadMessageAsync(localChatMessageId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.tryCancelDownloadMessageAsync');
+ }
+
+ tryCancelSendMessageAsync(localChatMessageId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.tryCancelSendMessageAsync');
+ }
+
+ getMessageBySyncIdAsync(syncId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatMessageStore.getMessageBySyncIdAsync');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`ChatMessageStore::addEventListener: ${name}`);
+ switch (name) {
+ case "messagechanged": // Foundation.TypedEventHandler
+ case "storechanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class ChatMessageStoreChangedEventArgs implements IChatMessageStoreChangedEventArgs {
+ id: string;
+ kind: ChatStoreChangedEventKind;
+
+ }
+ export class ChatMessageTransport implements IChatMessageTransport, IChatMessageTransport2 {
+ isActive: Boolean;
+ isAppSetAsNotificationProvider: Boolean;
+ transportFriendlyName: string;
+ transportId: string;
+ configuration: ChatMessageTransportConfiguration;
+ transportKind: ChatMessageTransportKind;
+
+ requestSetAsNotificationProviderAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatMessageTransport.requestSetAsNotificationProviderAsync');
+ }
+
+ }
+ export class ChatMessageTransportConfiguration implements IChatMessageTransportConfiguration {
+ extendedProperties: string[];
+ maxAttachmentCount: number;
+ maxMessageSizeInKilobytes: number;
+ maxRecipientCount: number;
+ supportedVideoFormat: Media.MediaProperties.MediaEncodingProfile;
+
+ }
+ export enum ChatMessageTransportKind {
+ text,
+ untriaged,
+ blocked,
+ custom,
+ }
+ export class ChatMessageValidationResult implements IChatMessageValidationResult {
+ maxPartCount: number | null;
+ partCount: number | null;
+ remainingCharacterCountInPart: number | null;
+ status: ChatMessageValidationStatus;
+
+ }
+ export enum ChatMessageValidationStatus {
+ valid,
+ noRecipients,
+ invalidData,
+ messageTooLarge,
+ tooManyRecipients,
+ transportInactive,
+ transportNotFound,
+ tooManyAttachments,
+ invalidRecipients,
+ invalidBody,
+ invalidOther,
+ validWithLargeMessage,
+ voiceRoamingRestriction,
+ dataRoamingRestriction,
+ }
+ export class ChatQueryOptions implements IChatQueryOptions {
+ // constructor();
+ searchString: string = '';
+
+ }
+ export class ChatRecipientDeliveryInfo implements IChatRecipientDeliveryInfo {
+ // constructor();
+ transportAddress: string = '';
+ readTime: Date | null;
+ deliveryTime: Date | null;
+ isErrorPermanent: Boolean = false;
+ status: ChatMessageStatus = ChatMessageStatus.sent;
+ transportErrorCode: number = 0;
+ transportErrorCodeCategory: ChatTransportErrorCodeCategory = ChatTransportErrorCodeCategory.none;
+ transportInterpretedErrorCode: ChatTransportInterpretedErrorCode = ChatTransportInterpretedErrorCode.none;
+
+ }
+ export enum ChatRestoreHistorySpan {
+ lastMonth,
+ lastYear,
+ anyTime,
+ }
+ export class ChatSearchReader implements IChatSearchReader {
+ readBatchAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatSearchReader.readBatchAsync');
+ }
+
+ readBatchAsync_1(count: number): Foundation.IAsyncOperation {
+ throw new Error('shimmed function ChatSearchReader.readBatchAsync_1');
+ }
+
+ }
+ export enum ChatStoreChangedEventKind {
+ notificationsMissed,
+ storeModified,
+ messageCreated,
+ messageModified,
+ messageDeleted,
+ conversationModified,
+ conversationDeleted,
+ conversationTransportDeleted,
+ }
+ export class ChatSyncConfiguration implements IChatSyncConfiguration {
+ restoreHistorySpan: ChatRestoreHistorySpan;
+ isSyncEnabled: Boolean;
+
+ }
+ export class ChatSyncManager implements IChatSyncManager {
+ configuration: ChatSyncConfiguration;
+
+ associateAccountAsync(webAccount: Security.Credentials.WebAccount): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatSyncManager.associateAccountAsync');
+ }
+
+ unassociateAccountAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatSyncManager.unassociateAccountAsync');
+ }
+
+ isAccountAssociated(webAccount: Security.Credentials.WebAccount): Boolean {
+ throw new Error('shimmed function ChatSyncManager.isAccountAssociated');
+ }
+
+ startSync(): void {
+ console.warn('shimmed function ChatSyncManager.startSync');
+ }
+
+ setConfigurationAsync(configuration: ChatSyncConfiguration): Foundation.IAsyncAction {
+ throw new Error('shimmed function ChatSyncManager.setConfigurationAsync');
+ }
+
+ }
+ export enum ChatTransportErrorCodeCategory {
+ none,
+ http,
+ network,
+ mmsServer,
+ }
+ export enum ChatTransportInterpretedErrorCode {
+ none,
+ unknown,
+ invalidRecipientAddress,
+ networkConnectivity,
+ serviceDenied,
+ timeout,
+ }
+ export interface IChatItem {
+ itemKind: ChatItemKind;
+ }
+ export class RcsEndUserMessage implements IRcsEndUserMessage {
+ actions: RcsEndUserMessageAction[];
+ isPinRequired: Boolean;
+ text: string;
+ title: string;
+ transportId: string;
+
+ sendResponseAsync(action: RcsEndUserMessageAction): Foundation.IAsyncAction {
+ throw new Error('shimmed function RcsEndUserMessage.sendResponseAsync');
+ }
+
+ sendResponseWithPinAsync(action: RcsEndUserMessageAction, pin: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function RcsEndUserMessage.sendResponseWithPinAsync');
+ }
+
+ }
+ export class RcsEndUserMessageAction implements IRcsEndUserMessageAction {
+ label: string;
+
+ }
+ export class RcsEndUserMessageAvailableEventArgs implements IRcsEndUserMessageAvailableEventArgs {
+ isMessageAvailable: Boolean;
+ message: RcsEndUserMessage;
+
+ }
+ export class RcsEndUserMessageAvailableTriggerDetails implements IRcsEndUserMessageAvailableTriggerDetails {
+ text: string;
+ title: string;
+
+ }
+ export class RcsEndUserMessageManager implements IRcsEndUserMessageManager {
+ addEventListener(name: string, handler: Function) {
+ console.warn(`RcsEndUserMessageManager::addEventListener: ${name}`);
+ switch (name) {
+ case "messageavailablechanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class RcsManager {
+ static getEndUserMessageManager(): RcsEndUserMessageManager {
+ throw new Error('shimmed function RcsManager.getEndUserMessageManager');
+ }
+
+ static getTransportsAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function RcsManager.getTransportsAsync');
+ }
+
+ static getTransportAsync(transportId: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function RcsManager.getTransportAsync');
+ }
+
+ static leaveConversationAsync(conversation: ChatConversation): Foundation.IAsyncAction {
+ throw new Error('shimmed function RcsManager.leaveConversationAsync');
+ }
+
+ static addEventListener(name: string, handler: Function) {
+ console.warn(`RcsManager::addEventListener: ${name}`);
+ switch (name) {
+ case "transportlistchanged": // /* System.EventHandler`1[[System.Object, System.Private.CoreLib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]] */ any
+ break;
+ }
+
+ }
+ }
+ export enum RcsServiceKind {
+ chat,
+ groupChat,
+ fileTransfer,
+ capability,
+ }
+ export class RcsServiceKindSupportedChangedEventArgs implements IRcsServiceKindSupportedChangedEventArgs {
+ serviceKind: RcsServiceKind;
+
+ }
+ export class RcsTransport implements IRcsTransport {
+ configuration: RcsTransportConfiguration;
+ extendedProperties: string[];
+ isActive: Boolean;
+ transportFriendlyName: string;
+ transportId: string;
+
+ isStoreAndForwardEnabled(serviceKind: RcsServiceKind): Boolean {
+ throw new Error('shimmed function RcsTransport.isStoreAndForwardEnabled');
+ }
+
+ isServiceKindSupported(serviceKind: RcsServiceKind): Boolean {
+ throw new Error('shimmed function RcsTransport.isServiceKindSupported');
+ }
+
+ addEventListener(name: string, handler: Function) {
+ console.warn(`RcsTransport::addEventListener: ${name}`);
+ switch (name) {
+ case "servicekindsupportedchanged": // Foundation.TypedEventHandler
+ break;
+ }
+
+ }
+ }
+ export class RcsTransportConfiguration implements IRcsTransportConfiguration {
+ maxAttachmentCount: number;
+ maxFileSizeInKilobytes: number;
+ maxGroupMessageSizeInKilobytes: number;
+ maxMessageSizeInKilobytes: number;
+ maxRecipientCount: number;
+ warningFileSizeInKilobytes: number;
+
+ }
+ export class RemoteParticipantComposingChangedEventArgs implements IRemoteParticipantComposingChangedEventArgs {
+ isComposing: Boolean;
+ participantAddress: string;
+ transportId: string;
+
+ }
+ }
+ export namespace CommunicationBlocking {
+ export class CommunicationBlockingAccessManager {
+ static isBlockingActive: Boolean = false;
+
+ static isBlockedNumberAsync(number: string): Foundation.IAsyncOperation {
+ throw new Error('shimmed function CommunicationBlockingAccessManager.isBlockedNumberAsync');
+ }
+
+ static showBlockNumbersUI(phoneNumbers: Foundation.Collections.IIterable): Boolean {
+ throw new Error('shimmed function CommunicationBlockingAccessManager.showBlockNumbersUI');
+ }
+
+ static showUnblockNumbersUI(phoneNumbers: Foundation.Collections.IIterable): Boolean {
+ throw new Error('shimmed function CommunicationBlockingAccessManager.showUnblockNumbersUI');
+ }
+
+ static showBlockedCallsUI(): void {
+ console.warn('shimmed function CommunicationBlockingAccessManager.showBlockedCallsUI');
+ }
+
+ static showBlockedMessagesUI(): void {
+ console.warn('shimmed function CommunicationBlockingAccessManager.showBlockedMessagesUI');
+ }
+
+ }
+ export class CommunicationBlockingAppManager {
+ static isCurrentAppActiveBlockingApp: Boolean;
+
+ static requestSetAsActiveBlockingAppAsync(): Foundation.IAsyncOperation {
+ throw new Error('shimmed function CommunicationBlockingAppManager.requestSetAsActiveBlockingAppAsync');
+ }
+
+ static showCommunicationBlockingSettingsUI(): void {
+ console.warn('shimmed function CommunicationBlockingAppManager.showCommunicationBlockingSettingsUI');
+ }
+
+ }
+ export interface CommunicationBlockingContract {
+ }
+ }
+ export namespace Contacts {
+ export class AggregateContactManager implements IAggregateContactManager, IAggregateContactManager2 {
+ findRawContactsAsync(contact: Contact): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AggregateContactManager.findRawContactsAsync');
+ }
+
+ tryLinkContactsAsync(primaryContact: Contact, secondaryContact: Contact): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AggregateContactManager.tryLinkContactsAsync');
+ }
+
+ unlinkRawContactAsync(contact: Contact): Foundation.IAsyncAction {
+ throw new Error('shimmed function AggregateContactManager.unlinkRawContactAsync');
+ }
+
+ trySetPreferredSourceForPictureAsync(aggregateContact: Contact, rawContact: Contact): Foundation.IAsyncOperation {
+ throw new Error('shimmed function AggregateContactManager.trySetPreferredSourceForPictureAsync');
+ }
+
+ setRemoteIdentificationInformationAsync(contactListId: string, remoteSourceId: string, accountId: string): Foundation.IAsyncAction {
+ throw new Error('shimmed function AggregateContactManager.setRemoteIdentificationInformationAsync');
+ }
+
+ }
+ export class Contact implements IContact, IContact2, IContactName, IContact3 {
+ // constructor();
+ thumbnail: Storage.Streams.IRandomAccessStreamReference;
+ name: string = '';
+ fields: IContactField[] = [ ];
+ id: string = '';
+ notes: string = '';
+ connectedServiceAccounts: ContactConnectedServiceAccount[] = [ ];
+ emails: ContactEmail[] = [ ];
+ addresses: ContactAddress[] = [ ];
+ importantDates: ContactDate[] = [ ];
+ jobInfo: ContactJobInfo[] = [ ];
+ dataSuppliers: string[] = [ ];
+ phones: ContactPhone[] = [ ];
+ providerProperties: Foundation.Collections.IPropertySet = [ ];
+ significantOthers: ContactSignificantOther[] = [ ];
+ websites: ContactWebsite[] = [ ];
+ sourceDisplayPicture: Storage.Streams.IRandomAccessStreamReference;
+ textToneToken: string = '';
+ displayNameOverride: string = '';
+ displayPictureUserUpdateTime: Date = new Date(-11644473600000);
+ nickname: string = '';
+ remoteId: string = '';
+ ringToneToken: string = '';
+ contactListId: string = '';
+ largeDisplayPicture: Storage.Streams.IRandomAccessStreamReference;
+ smallDisplayPicture: Storage.Streams.IRandomAccessStreamReference;
+ sortName: string = '';
+ aggregateId: string = '';
+ fullName: string = '';
+ isAggregate: Boolean = false;
+ isDisplayPictureManuallySet: Boolean = false;
+ isMe: Boolean = false;
+ yomiGivenName: string = '';
+ honorificNameSuffix: string = '';
+ yomiFamilyName: string = '';
+ middleName: string = '';
+ lastName: string = '';
+ honorificNamePrefix: string = '';
+ firstName: string = '';
+ displayName: string = '';
+ yomiDisplayName: string = '';
+
+ }
+ export class ContactAddress implements IContactAddress {
+ // constructor();
+ streetAddress: string = '';
+ region: string = '';
+ postalCode: string = '';
+ locality: string = '';
+ kind: ContactAddressKind = ContactAddressKind.home;
+ description: string = '';
+ country: string = '';
+
+ }
+ export enum ContactAddressKind {
+ home,
+ work,
+ other,
+ }
+ export class ContactAnnotation implements IContactAnnotation, IContactAnnotation2 {
+ // constructor();
+ supportedOperations: ContactAnnotationOperations = ContactAnnotationOperations.none;
+ remoteId: string = '';
+ contactId: string = '';
+ annotationListId: string = '';
+ id: string = '';
+ isDisabled: Boolean = false;
+ providerProperties: Foundation.Collections.ValueSet = [ ];
+ contactListId: string = '';
+
+ }
+ export class ContactAnnotationList implements IContactAnnotationList {
+ id: string;
+ providerPackageFamilyName: string;
+ userDataAccountId: string;
+
+ deleteAsync(): Foundation.IAsyncAction {
+ throw new Error('shimmed function ContactAnnotationList.deleteAsync');
+ }
+
+ trySaveAnnotationAsync(annotation: ContactAnnotation): Foundation.IAsyncOperation