@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/codec/lifecycle/definition/DeviceDefinitionWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceDefinitionWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const DeviceDefinitionCodec_1 = require("../../definition/DeviceDefinitionCodec");
+class DeviceDefinitionWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: DeviceDefinitionCodec_1.DeviceDefinitionCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, DeviceDefinitionCodec_1.DeviceDefinitionCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.DeviceDefinitionWithLifecycleCodec = DeviceDefinitionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/definition/EventDefinitionWithLifecycleCodec.d.ts

@@ -0,0 +1,11 @@
+import { EventDefinition } from '../../../typedef/definition/EventDefinition';
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+export declare class EventDefinitionWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<EventDefinition>): {
+        lifecycle: string;
+        definition: any;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<EventDefinition>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<EventDefinition>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<EventDefinition>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/definition/EventDefinitionWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDefinitionWithLifecycleCodec = void 0;
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const EventDefinitionCodec_1 = require("../../definition/EventDefinitionCodec");
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+class EventDefinitionWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: EventDefinitionCodec_1.EventDefinitionCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, EventDefinitionCodec_1.EventDefinitionCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.EventDefinitionWithLifecycleCodec = EventDefinitionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/definition/FormatDefinitionWithLifecycleCodec.d.ts

@@ -0,0 +1,11 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { FormatDefinition } from '../../../typedef/definition/FormatDefinition';
+export declare class FormatDefinitionWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<FormatDefinition>): {
+        lifecycle: string;
+        definition: any;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<FormatDefinition>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<FormatDefinition>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<FormatDefinition>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/definition/FormatDefinitionWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatDefinitionWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const FormatDefinitionCodec_1 = require("../../definition/FormatDefinitionCodec");
+class FormatDefinitionWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: FormatDefinitionCodec_1.FormatDefinitionCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, FormatDefinitionCodec_1.FormatDefinitionCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.FormatDefinitionWithLifecycleCodec = FormatDefinitionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/definition/PropertyDefinitionWithLifecycleCodec.d.ts

@@ -0,0 +1,8 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { PropertyDefinition } from '../../../typedef/definition/PropertyDefinition';
+export declare class PropertyDefinitionWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<PropertyDefinition>): any;
+    static encodeArray(resource: ObjectWithLifecycle<PropertyDefinition>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<PropertyDefinition>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<PropertyDefinition>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/definition/PropertyDefinitionWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyDefinitionWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const PropertyDefinitionCodec_1 = require("../../definition/PropertyDefinitionCodec");
+class PropertyDefinitionWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: PropertyDefinitionCodec_1.PropertyDefinitionCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, PropertyDefinitionCodec_1.PropertyDefinitionCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.PropertyDefinitionWithLifecycleCodec = PropertyDefinitionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/definition/ServiceDefinitionWithLifecycleCodec.d.ts

@@ -0,0 +1,11 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { ServiceDefinition } from '../../../typedef/definition/ServiceDefinition';
+export declare class ServiceDefinitionWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<ServiceDefinition>): {
+        lifecycle: string;
+        definition: any;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<ServiceDefinition>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<ServiceDefinition>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<ServiceDefinition>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/definition/ServiceDefinitionWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDefinitionWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const ServiceDefinitionCodec_1 = require("../../definition/ServiceDefinitionCodec");
+class ServiceDefinitionWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: ServiceDefinitionCodec_1.ServiceDefinitionCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, ServiceDefinitionCodec_1.ServiceDefinitionCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.ServiceDefinitionWithLifecycleCodec = ServiceDefinitionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/definition/UnitDefinitionWithLifecycleCodec.d.ts

@@ -0,0 +1,11 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { UnitDefinition } from '../../../typedef/definition/UnitDefinition';
+export declare class UnitDefinitionWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<UnitDefinition>): {
+        lifecycle: string;
+        definition: any;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<UnitDefinition>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<UnitDefinition>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<UnitDefinition>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/definition/UnitDefinitionWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitDefinitionWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const UnitDefinitionCodec_1 = require("../../definition/UnitDefinitionCodec");
+class UnitDefinitionWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: UnitDefinitionCodec_1.UnitDefinitionCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, UnitDefinitionCodec_1.UnitDefinitionCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.UnitDefinitionWithLifecycleCodec = UnitDefinitionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/instance/DeviceInstanceWithLifecycleCodec.d.ts

@@ -0,0 +1,11 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { DeviceInstance } from '../../../typedef/instance/DeviceInstance';
+export declare class DeviceInstanceWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<DeviceInstance>): {
+        lifecycle: string;
+        definition: any;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<DeviceInstance>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<DeviceInstance>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<DeviceInstance>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/instance/DeviceInstanceWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceInstanceWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const DeviceInstanceCodec_1 = require("../../instance/DeviceInstanceCodec");
+class DeviceInstanceWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: DeviceInstanceCodec_1.DeviceInstanceCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, DeviceInstanceCodec_1.DeviceInstanceCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.DeviceInstanceWithLifecycleCodec = DeviceInstanceWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/product/VersionWithLifecycleCodec.d.ts

@@ -0,0 +1,10 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+export declare class VersionWithLifecycleCodec {
+    static encode(o: ObjectWithLifecycle<Number>): {
+        lifecycle: string;
+        version: Number;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<Number>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<Number>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<Number>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/product/VersionWithLifecycleCodec.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionWithLifecycleCodec = void 0;
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+class VersionWithLifecycleCodec {
+    static encode(o) {
+        return {
+            lifecycle: o.lifecycle.toString(),
+            version: o.value
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const version = o.version;
+        if (typeof version === 'number') {
+            return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, version);
+        }
+        else {
+            return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, 0);
+        }
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.VersionWithLifecycleCodec = VersionWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/template/DeviceTemplateWithLifecycleCodec.d.ts

@@ -0,0 +1,11 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { DeviceTemplate } from '../../../typedef/template/DeviceTemplate';
+export declare class DeviceTemplateWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<DeviceTemplate>): {
+        lifecycle: string;
+        definition: any;
+    };
+    static encodeArray(resource: ObjectWithLifecycle<DeviceTemplate>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<DeviceTemplate>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<DeviceTemplate>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/template/DeviceTemplateWithLifecycleCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTemplateWithLifecycleCodec = void 0;
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const DeviceTemplateCodec_1 = require("../../template/DeviceTemplateCodec");
+class DeviceTemplateWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle.toString(),
+            definition: DeviceTemplateCodec_1.DeviceTemplateCodec.encode(obj.value)
+        };
+    }
+    static encodeArray(resource) {
+        const arr = [];
+        resource.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        const definition = o.definition;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, DeviceTemplateCodec_1.DeviceTemplateCodec.decode(definition));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                if (typeof o === 'object') {
+                    list.push(this.decode(o));
+                }
+            }
+        }
+        return list;
+    }
+}
+exports.DeviceTemplateWithLifecycleCodec = DeviceTemplateWithLifecycleCodec;

package/dist/xiot/core/spec/codec/lifecycle/type/DeviceTypeWithLifecycleCodec.d.ts

@@ -0,0 +1,12 @@
+import { ObjectWithLifecycle } from '../../../typedef/lifecycle/ObjectWithLifecycle';
+import { LifeCycle } from '../../../typedef/lifecycle/Lifecycle';
+import { DeviceType } from '../../../typedef/definition/urn/DeviceType';
+export declare class DeviceTypeWithLifecycleCodec {
+    static encode(obj: ObjectWithLifecycle<DeviceType>): {
+        lifecycle: LifeCycle;
+        type: string;
+    };
+    static encodeArray(devicesTypes: ObjectWithLifecycle<DeviceType>[]): any[];
+    static decode(o: any): ObjectWithLifecycle<DeviceType>;
+    static decodeArray(arr: any[]): ObjectWithLifecycle<DeviceType>[];
+}

package/dist/xiot/core/spec/codec/lifecycle/type/DeviceTypeWithLifecycleCodec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTypeWithLifecycleCodec = void 0;
+const ObjectWithLifecycle_1 = require("../../../typedef/lifecycle/ObjectWithLifecycle");
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const DeviceType_1 = require("../../../typedef/definition/urn/DeviceType");
+class DeviceTypeWithLifecycleCodec {
+    static encode(obj) {
+        return {
+            lifecycle: obj.lifecycle,
+            type: obj.value.toString()
+        };
+    }
+    static encodeArray(devicesTypes) {
+        const arr = [];
+        devicesTypes.forEach(item => {
+            arr.push(this.encode(item));
+        });
+        return arr;
+    }
+    static decode(o) {
+        const lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle);
+        const { type } = o;
+        return new ObjectWithLifecycle_1.ObjectWithLifecycle(lifecycle, new DeviceType_1.DeviceType(type));
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.decode(o));
+            }
+        }
+        return list;
+    }
+}
+exports.DeviceTypeWithLifecycleCodec = DeviceTypeWithLifecycleCodec;

package/dist/xiot/core/spec/codec/notice/DeviceNoticeCodec.d.ts

@@ -0,0 +1,8 @@
+import { NoticeCodec } from '../../typedef/notice/NoticeCodec';
+import { DeviceNotice } from '../../typedef/notice/device/DeviceNotice';
+export declare class DeviceNoticeCodec extends NoticeCodec<DeviceNotice, any> {
+    mainType(): string;
+    encode(x: DeviceNotice): any;
+    decode(subType: string, o: any): DeviceNotice;
+    decodeObject(o: any): DeviceNotice;
+}

package/dist/xiot/core/spec/codec/notice/DeviceNoticeCodec.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceNoticeCodec = void 0;
+const NoticeCodec_1 = require("../../typedef/notice/NoticeCodec");
+const DeviceNoticeType_1 = require("../../typedef/notice/device/DeviceNoticeType");
+const DeviceAccessKeyChangedCodec_1 = require("./device/DeviceAccessKeyChangedCodec");
+const DeviceAccessKeyChanged_1 = require("../../typedef/notice/device/impl/DeviceAccessKeyChanged");
+const DeviceChildrenAdded_1 = require("../../typedef/notice/device/impl/DeviceChildrenAdded");
+const DeviceChildrenAddedCodec_1 = require("./device/DeviceChildrenAddedCodec");
+const DeviceChildrenRemoved_1 = require("../../typedef/notice/device/impl/DeviceChildrenRemoved");
+const DeviceChildrenRemovedCodec_1 = require("./device/DeviceChildrenRemovedCodec");
+const DevicePropertiesChanged_1 = require("../../typedef/notice/device/impl/DevicePropertiesChanged");
+const DevicePropertiesChangedCodec_1 = require("./device/DevicePropertiesChangedCodec");
+const DevicePropertyChanged_1 = require("../../typedef/notice/device/impl/DevicePropertyChanged");
+const DevicePropertyChangedCodec_1 = require("./device/DevicePropertyChangedCodec");
+const DeviceEventOccurred_1 = require("../../typedef/notice/device/impl/DeviceEventOccurred");
+const DeviceEventOccurredCodec_1 = require("./device/DeviceEventOccurredCodec");
+const DeviceRootActive_1 = require("../../typedef/notice/device/impl/DeviceRootActive");
+const DeviceRootActiveCodec_1 = require("./device/DeviceRootActiveCodec");
+const DeviceRootInactive_1 = require("../../typedef/notice/device/impl/DeviceRootInactive");
+const DeviceRootInactiveCodec_1 = require("./device/DeviceRootInactiveCodec");
+const DeviceSummaryChanged_1 = require("../../typedef/notice/device/impl/DeviceSummaryChanged");
+const DeviceSummaryChangedCodec_1 = require("./device/DeviceSummaryChangedCodec");
+class DeviceNoticeCodec extends NoticeCodec_1.NoticeCodec {
+    mainType() {
+        return 'device';
+    }
+    encode(x) {
+        let o = {};
+        switch ((0, DeviceNoticeType_1.DeviceNoticeTypeFromString)(x.subType())) {
+            case DeviceNoticeType_1.DeviceNoticeType.UNDEFINED:
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.ACCESSKEY_CHANGED:
+                if (x instanceof DeviceAccessKeyChanged_1.DeviceAccessKeyChanged) {
+                    o = DeviceAccessKeyChangedCodec_1.DeviceAccessKeyChangedCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.CHILDREN_ADDED:
+                if (x instanceof DeviceChildrenAdded_1.DeviceChildrenAdded) {
+                    o = DeviceChildrenAddedCodec_1.DeviceChildrenAddedCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.CHILDREN_REMOVED:
+                if (x instanceof DeviceChildrenRemoved_1.DeviceChildrenRemoved) {
+                    o = DeviceChildrenRemovedCodec_1.DeviceChildrenRemovedCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.PROPERTIES_CHANGED:
+                if (x instanceof DevicePropertiesChanged_1.DevicePropertiesChanged) {
+                    o = DevicePropertiesChangedCodec_1.DevicePropertiesChangedCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.PROPERTY_CHANGED:
+                if (x instanceof DevicePropertyChanged_1.DevicePropertyChanged) {
+                    o = DevicePropertyChangedCodec_1.DevicePropertyChangedCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.EVENT_OCCURRED:
+                if (x instanceof DeviceEventOccurred_1.DeviceEventOccurred) {
+                    o = DeviceEventOccurredCodec_1.DeviceEventOccurredCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.ROOT_ACTIVE:
+                if (x instanceof DeviceRootActive_1.DeviceRootActive) {
+                    o = DeviceRootActiveCodec_1.DeviceRootActiveCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.ROOT_INACTIVE:
+                if (x instanceof DeviceRootInactive_1.DeviceRootInactive) {
+                    o = DeviceRootInactiveCodec_1.DeviceRootInactiveCodec.encode(x);
+                }
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.SUMMARY_CHANGED:
+                if (x instanceof DeviceSummaryChanged_1.DeviceSummaryChanged) {
+                    o = DeviceSummaryChangedCodec_1.DeviceSummaryChangedCodec.encode(x);
+                }
+                break;
+            default:
+                break;
+        }
+        return o;
+    }
+    decode(subType, o) {
+        let notice;
+        switch (subType) {
+            case DeviceNoticeType_1.DeviceNoticeType.ACCESSKEY_CHANGED:
+                notice = DeviceAccessKeyChangedCodec_1.DeviceAccessKeyChangedCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.CHILDREN_ADDED:
+                notice = DeviceChildrenAddedCodec_1.DeviceChildrenAddedCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.CHILDREN_REMOVED:
+                notice = DeviceChildrenRemovedCodec_1.DeviceChildrenRemovedCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.EVENT_OCCURRED:
+                notice = DeviceEventOccurredCodec_1.DeviceEventOccurredCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.PROPERTIES_CHANGED:
+                notice = DevicePropertiesChangedCodec_1.DevicePropertiesChangedCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.PROPERTY_CHANGED:
+                notice = DevicePropertyChangedCodec_1.DevicePropertyChangedCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.ROOT_ACTIVE:
+                notice = DeviceRootActiveCodec_1.DeviceRootActiveCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.ROOT_INACTIVE:
+                notice = DeviceRootInactiveCodec_1.DeviceRootInactiveCodec.decode(o);
+                break;
+            case DeviceNoticeType_1.DeviceNoticeType.SUMMARY_CHANGED:
+                notice = DeviceSummaryChangedCodec_1.DeviceSummaryChangedCodec.decode(o);
+                break;
+            default:
+                throw new Error(`invalid subType: ${subType}`);
+        }
+        return notice;
+    }
+    decodeObject(o) {
+        return this.decode(o.type, o.payload);
+    }
+}
+exports.DeviceNoticeCodec = DeviceNoticeCodec;

package/dist/xiot/core/spec/codec/notice/OwnerNoticeCodec.d.ts

@@ -0,0 +1,8 @@
+import { NoticeCodec } from '../../typedef/notice/NoticeCodec';
+import { OwnerNotice } from '../../typedef/notice/owner/OwnerNotice';
+export declare class OwnerNoticeCodec extends NoticeCodec<OwnerNotice, any> {
+    mainType(): string;
+    encode(x: OwnerNotice): any;
+    decode(subType: string, o: any): OwnerNotice;
+    decodeObject(o: any): OwnerNotice;
+}