@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/instance/PropertyValue.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyValue = void 0;
+const DataFormat_1 = require("../definition/property/data/DataFormat");
+const DataValueFactory_1 = require("../definition/property/data/DataValueFactory");
+class PropertyValue {
+    static copy(o) {
+        const thiz = new PropertyValue(o.format);
+        thiz.initValue = o.initValue;
+        thiz.defaultValue = o.defaultValue;
+        thiz.currentValue = o.currentValue;
+        thiz._stringValue = o._stringValue;
+        thiz._numberValue = o._numberValue;
+        thiz._booleanValue = o._booleanValue;
+        return thiz;
+    }
+    constructor(format) {
+        this.format = DataFormat_1.DataFormat.BOOL;
+        this.defaultValue = null;
+        this.currentValue = null;
+        this._stringValue = '';
+        this._numberValue = 0;
+        this._booleanValue = false;
+        this.format = format;
+        this.initValue = DataValueFactory_1.DataValueFactory.createDefaultValue(format);
+        this.refreshValueForDebuggerOrSimulator();
+    }
+    update(newValue) {
+        if (newValue == null) {
+            throw new Error('update failed: newValue is null');
+        }
+        if (!(0, DataFormat_1.DataFormatCheck)(this.format, newValue)) {
+            throw new Error('update failed: newValue invalid format');
+        }
+        this.currentValue = newValue;
+        this.refreshValueForDebuggerOrSimulator();
+    }
+    value() {
+        if (this.currentValue != null) {
+            return this.currentValue;
+        }
+        if (this.defaultValue != null) {
+            return this.defaultValue;
+        }
+        return this.initValue;
+    }
+    /*----------------------------------------------------------------------
+     * for debugger or simulator
+     *----------------------------------------------------------------------*/
+    refreshValueForDebuggerOrSimulator() {
+        switch (this.format) {
+            case DataFormat_1.DataFormat.BOOL:
+                this._booleanValue = this.value().rawValue();
+                this._stringValue = this._booleanValue.toString();
+                break;
+            case DataFormat_1.DataFormat.FLOAT:
+            case DataFormat_1.DataFormat.UINT8:
+            case DataFormat_1.DataFormat.UINT16:
+            case DataFormat_1.DataFormat.UINT32:
+            case DataFormat_1.DataFormat.INT8:
+            case DataFormat_1.DataFormat.INT16:
+            case DataFormat_1.DataFormat.INT32:
+            case DataFormat_1.DataFormat.INT64:
+                this._numberValue = this.value().rawValue();
+                this._stringValue = this._numberValue.toString();
+                break;
+            case DataFormat_1.DataFormat.STRING:
+                this._stringValue = this.value().rawValue();
+                break;
+            case DataFormat_1.DataFormat.TLV8:
+                this._stringValue = this.value().rawValue();
+                break;
+            case DataFormat_1.DataFormat.HEX:
+                this._stringValue = this.value().rawValue();
+                break;
+            default:
+                break;
+        }
+    }
+}
+exports.PropertyValue = PropertyValue;

package/dist/xiot/core/spec/typedef/instance/Service.d.ts

@@ -0,0 +1,19 @@
+import { ServiceType } from '../definition/urn/ServiceType';
+import { Property } from './Property';
+import { Action } from './Action';
+import { Event } from './Event';
+export declare class Service {
+    iid: number;
+    type: ServiceType;
+    description: Map<string, string>;
+    properties: Map<number, Property>;
+    actions: Map<number, Action>;
+    events: Map<number, Event>;
+    _readablePropertiesCount: number;
+    _writablePropertiesCount: number;
+    _notifiablePropertiesCount: number;
+    constructor(iid: number, type: ServiceType, description: Map<string, string>, properties: Property[], actions: Action[], events: Event[]);
+    getProperties(): Property[];
+    getActions(): Action[];
+    getEvents(): Event[];
+}

package/dist/xiot/core/spec/typedef/instance/Service.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+class Service {
+    constructor(iid, type, description, properties, actions, events) {
+        this.iid = 0;
+        this.description = new Map();
+        this.properties = new Map();
+        this.actions = new Map();
+        this.events = new Map();
+        this._readablePropertiesCount = 0;
+        this._writablePropertiesCount = 0;
+        this._notifiablePropertiesCount = 0;
+        this.iid = iid;
+        this.type = type;
+        this.description = description;
+        properties.forEach(x => {
+            return this.properties.set(x.iid, x);
+        });
+        actions.forEach(x => {
+            return this.actions.set(x.iid, x);
+        });
+        events.forEach(x => {
+            return this.events.set(x.iid, x);
+        });
+        properties.forEach(x => {
+            if (x.access.isReadable) {
+                this._readablePropertiesCount++;
+            }
+            if (x.access.isWritable) {
+                this._writablePropertiesCount++;
+            }
+            if (x.access.isNotifiable) {
+                this._notifiablePropertiesCount++;
+            }
+        });
+    }
+    getProperties() {
+        return Array.from(this.properties.values());
+    }
+    getActions() {
+        return Array.from(this.actions.values());
+    }
+    getEvents() {
+        return Array.from(this.events.values());
+    }
+}
+exports.Service = Service;

package/dist/xiot/core/spec/typedef/jwt/Jwt.d.ts

@@ -0,0 +1,10 @@
+import { JwtType } from './JwtType';
+export declare abstract class Jwt {
+    type: JwtType;
+    algorithm: string;
+    expiresInSeconds: number;
+    protected constructor(type: JwtType);
+}
+export declare const DEFAULT_SECRETS_SIGNATURE_ALGORITHM = "HS256";
+export declare const DEFAULT_RSA_SIGNATURE_ALGORITHM = "RS256";
+export declare const DEFAULT_ES_SIGNATURE_ALGORITHM = "ES256";

package/dist/xiot/core/spec/typedef/jwt/Jwt.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ES_SIGNATURE_ALGORITHM = exports.DEFAULT_RSA_SIGNATURE_ALGORITHM = exports.DEFAULT_SECRETS_SIGNATURE_ALGORITHM = exports.Jwt = void 0;
+const JwtType_1 = require("./JwtType");
+class Jwt {
+    constructor(type) {
+        this.type = JwtType_1.JwtType.UNDEFINED;
+        this.algorithm = exports.DEFAULT_SECRETS_SIGNATURE_ALGORITHM;
+        this.expiresInSeconds = 0;
+        this.type = type;
+    }
+}
+exports.Jwt = Jwt;
+exports.DEFAULT_SECRETS_SIGNATURE_ALGORITHM = 'HS256';
+exports.DEFAULT_RSA_SIGNATURE_ALGORITHM = 'RS256';
+exports.DEFAULT_ES_SIGNATURE_ALGORITHM = 'ES256';

package/dist/xiot/core/spec/typedef/jwt/JwtType.d.ts

@@ -0,0 +1,8 @@
+export declare enum JwtType {
+    UNDEFINED = "undefined",
+    SECRETS = "secrets",
+    RSA = "rsa",
+    ES = "es"
+}
+export declare function JwtTypeToString(type: JwtType): string;
+export declare function JwtTypeFromString(type: string): JwtType;

package/dist/xiot/core/spec/typedef/jwt/JwtType.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtType = void 0;
+exports.JwtTypeToString = JwtTypeToString;
+exports.JwtTypeFromString = JwtTypeFromString;
+var JwtType;
+(function (JwtType) {
+    JwtType["UNDEFINED"] = "undefined";
+    JwtType["SECRETS"] = "secrets";
+    JwtType["RSA"] = "rsa";
+    JwtType["ES"] = "es";
+})(JwtType || (exports.JwtType = JwtType = {}));
+function JwtTypeToString(type) {
+    return type.toString();
+}
+function JwtTypeFromString(type) {
+    const keys = Object.keys(JwtType);
+    for (const key of keys) {
+        const s = JwtTypeToString(JwtType[key]);
+        if (s === type) {
+            return JwtType[key];
+        }
+    }
+    return JwtType.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/jwt/impl/JwtEsImpl.d.ts

@@ -0,0 +1,6 @@
+import { Jwt } from '../Jwt';
+export declare class JwtEsImpl extends Jwt {
+    publicKey: string;
+    privateKey: string;
+    constructor(publicKey: string, privateKey: string);
+}

package/dist/xiot/core/spec/typedef/jwt/impl/JwtEsImpl.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtEsImpl = void 0;
+const Jwt_1 = require("../Jwt");
+const JwtType_1 = require("../JwtType");
+class JwtEsImpl extends Jwt_1.Jwt {
+    constructor(publicKey, privateKey) {
+        super(JwtType_1.JwtType.ES);
+        this.publicKey = '';
+        this.privateKey = '';
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+    }
+}
+exports.JwtEsImpl = JwtEsImpl;

package/dist/xiot/core/spec/typedef/jwt/impl/JwtRsaImpl.d.ts

@@ -0,0 +1,6 @@
+import { Jwt } from '../Jwt';
+export declare class JwtRsaImpl extends Jwt {
+    publicKey: string;
+    privateKey: string;
+    constructor(publicKey: string, privateKey: string);
+}

package/dist/xiot/core/spec/typedef/jwt/impl/JwtRsaImpl.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtRsaImpl = void 0;
+const Jwt_1 = require("../Jwt");
+const JwtType_1 = require("../JwtType");
+class JwtRsaImpl extends Jwt_1.Jwt {
+    constructor(publicKey, privateKey) {
+        super(JwtType_1.JwtType.RSA);
+        this.publicKey = '';
+        this.privateKey = '';
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+    }
+}
+exports.JwtRsaImpl = JwtRsaImpl;

package/dist/xiot/core/spec/typedef/jwt/impl/JwtSecretsImpl.d.ts

@@ -0,0 +1,5 @@
+import { Jwt } from '../Jwt';
+export declare class JwtSecretsImpl extends Jwt {
+    key: string;
+    constructor(key: string);
+}

package/dist/xiot/core/spec/typedef/jwt/impl/JwtSecretsImpl.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtSecretsImpl = void 0;
+const Jwt_1 = require("../Jwt");
+const JwtType_1 = require("../JwtType");
+class JwtSecretsImpl extends Jwt_1.Jwt {
+    constructor(key) {
+        super(JwtType_1.JwtType.SECRETS);
+        this.key = '';
+        this.key = key;
+    }
+}
+exports.JwtSecretsImpl = JwtSecretsImpl;

package/dist/xiot/core/spec/typedef/key/AccessKey.d.ts

@@ -0,0 +1,5 @@
+export declare class AccessKey {
+    did: string;
+    key: string;
+    constructor(did: string, key: string);
+}

package/dist/xiot/core/spec/typedef/key/AccessKey.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessKey = void 0;
+class AccessKey {
+    constructor(did, key) {
+        this.did = did;
+        this.key = key;
+    }
+}
+exports.AccessKey = AccessKey;

package/dist/xiot/core/spec/typedef/key/DeviceCert.d.ts

@@ -0,0 +1,7 @@
+export declare class DeviceCert {
+    productId: string;
+    serialNumber: string;
+    cert: string;
+    key: string;
+    constructor(productId: string, serialNumber: string, cert: string, key: string);
+}

package/dist/xiot/core/spec/typedef/key/DeviceCert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceCert = void 0;
+class DeviceCert {
+    constructor(productId, serialNumber, cert, key) {
+        this.productId = productId;
+        this.serialNumber = serialNumber;
+        this.cert = cert;
+        this.key = key;
+    }
+}
+exports.DeviceCert = DeviceCert;

package/dist/xiot/core/spec/typedef/key/DeviceKey.d.ts

@@ -0,0 +1,8 @@
+export declare class DeviceKey {
+    did: string;
+    ltpk: string;
+    ltsk: string;
+    seed: string;
+    productId: string;
+    constructor(did: string, ltpk: string, ltsk: string, seed: string, productId: string);
+}

package/dist/xiot/core/spec/typedef/key/DeviceKey.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceKey = void 0;
+class DeviceKey {
+    constructor(did, ltpk, ltsk, seed, productId) {
+        this.did = did;
+        this.ltpk = ltpk;
+        this.ltsk = ltsk;
+        this.seed = seed;
+        this.productId = productId;
+    }
+}
+exports.DeviceKey = DeviceKey;

package/dist/xiot/core/spec/typedef/lifecycle/Lifecycle.d.ts

@@ -0,0 +1,8 @@
+export declare enum LifeCycle {
+    UNDEFINED = "undefined",
+    DEVELOPMENT = "development",
+    PREVIEW = "preview",
+    RELEASED = "released"
+}
+export declare function LifeCycleToString(lifecycle: LifeCycle): string;
+export declare function LifeCycleFromString(lifecycle: string): LifeCycle;

package/dist/xiot/core/spec/typedef/lifecycle/Lifecycle.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifeCycle = void 0;
+exports.LifeCycleToString = LifeCycleToString;
+exports.LifeCycleFromString = LifeCycleFromString;
+var LifeCycle;
+(function (LifeCycle) {
+    LifeCycle["UNDEFINED"] = "undefined";
+    LifeCycle["DEVELOPMENT"] = "development";
+    LifeCycle["PREVIEW"] = "preview";
+    LifeCycle["RELEASED"] = "released";
+})(LifeCycle || (exports.LifeCycle = LifeCycle = {}));
+function LifeCycleToString(lifecycle) {
+    return lifecycle.toString();
+}
+function LifeCycleFromString(lifecycle) {
+    const keys = Object.keys(LifeCycle);
+    for (const key of keys) {
+        const s = LifeCycleToString(LifeCycle[key]);
+        if (s === lifecycle) {
+            return LifeCycle[key];
+        }
+    }
+    return LifeCycle.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/lifecycle/ObjectWithLifecycle.d.ts

@@ -0,0 +1,6 @@
+import { LifeCycle } from './Lifecycle';
+export declare class ObjectWithLifecycle<T> {
+    lifecycle: LifeCycle;
+    value: T;
+    constructor(lifecycle: LifeCycle, value: T);
+}

package/dist/xiot/core/spec/typedef/lifecycle/ObjectWithLifecycle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectWithLifecycle = void 0;
+class ObjectWithLifecycle {
+    constructor(lifecycle, value) {
+        this.lifecycle = lifecycle;
+        this.value = value;
+    }
+}
+exports.ObjectWithLifecycle = ObjectWithLifecycle;

package/dist/xiot/core/spec/typedef/notice/Notice.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class Notice {
+    timestamp: number;
+    protected constructor(timestamp: number);
+    abstract mainType(): string;
+    abstract subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/Notice.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notice = void 0;
+class Notice {
+    constructor(timestamp) {
+        this.timestamp = timestamp;
+    }
+}
+exports.Notice = Notice;

package/dist/xiot/core/spec/typedef/notice/NoticeCodec.d.ts

@@ -0,0 +1,27 @@
+import { Notice } from './Notice';
+export declare abstract class NoticeCodec<T extends Notice, K> {
+    /**
+     * main type of notice
+     * @return type
+     */
+    abstract mainType(): string;
+    /**
+     * encode notice to Object
+     * @param record notice
+     * @return Object
+     */
+    abstract encode(record: K): K;
+    /**
+     * decode Object to notice
+     * @param subType subType of notice
+     * @param object Object
+     * @return notice
+     */
+    abstract decode(subType: string, object: K): T | null;
+    /**
+     * decode object to notice
+     * @param object Object
+     * @return notice
+     */
+    abstract decodeObject(object: any): T | null;
+}

package/dist/xiot/core/spec/typedef/notice/NoticeCodec.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoticeCodec = void 0;
+class NoticeCodec {
+}
+exports.NoticeCodec = NoticeCodec;

package/dist/xiot/core/spec/typedef/notice/device/DeviceNotice.d.ts

@@ -0,0 +1,6 @@
+import { Notice } from '../Notice';
+export declare abstract class DeviceNotice extends Notice {
+    protected constructor(timestamp: number);
+    mainType(): string;
+    abstract subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/device/DeviceNotice.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceNotice = void 0;
+const Notice_1 = require("../Notice");
+class DeviceNotice extends Notice_1.Notice {
+    constructor(timestamp) {
+        super(timestamp);
+    }
+    mainType() {
+        return 'device';
+    }
+}
+exports.DeviceNotice = DeviceNotice;

package/dist/xiot/core/spec/typedef/notice/device/DeviceNoticeType.d.ts

@@ -0,0 +1,14 @@
+export declare enum DeviceNoticeType {
+    UNDEFINED = "undefined",
+    PROPERTIES_CHANGED = "properties-changed",
+    PROPERTY_CHANGED = "property-changed",
+    EVENT_OCCURRED = "event-occurred",
+    CHILDREN_REMOVED = "children-removed",
+    CHILDREN_ADDED = "children-added",
+    ACCESSKEY_CHANGED = "accesskey-changed",
+    ROOT_ACTIVE = "root-active",
+    ROOT_INACTIVE = "root-inactive",
+    SUMMARY_CHANGED = "summary-changed"
+}
+export declare function DeviceNoticeTypeToString(type: DeviceNoticeType): string;
+export declare function DeviceNoticeTypeFromString(type: string): DeviceNoticeType;

package/dist/xiot/core/spec/typedef/notice/device/DeviceNoticeType.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceNoticeType = void 0;
+exports.DeviceNoticeTypeToString = DeviceNoticeTypeToString;
+exports.DeviceNoticeTypeFromString = DeviceNoticeTypeFromString;
+var DeviceNoticeType;
+(function (DeviceNoticeType) {
+    DeviceNoticeType["UNDEFINED"] = "undefined";
+    DeviceNoticeType["PROPERTIES_CHANGED"] = "properties-changed";
+    DeviceNoticeType["PROPERTY_CHANGED"] = "property-changed";
+    DeviceNoticeType["EVENT_OCCURRED"] = "event-occurred";
+    DeviceNoticeType["CHILDREN_REMOVED"] = "children-removed";
+    DeviceNoticeType["CHILDREN_ADDED"] = "children-added";
+    DeviceNoticeType["ACCESSKEY_CHANGED"] = "accesskey-changed";
+    DeviceNoticeType["ROOT_ACTIVE"] = "root-active";
+    DeviceNoticeType["ROOT_INACTIVE"] = "root-inactive";
+    DeviceNoticeType["SUMMARY_CHANGED"] = "summary-changed";
+})(DeviceNoticeType || (exports.DeviceNoticeType = DeviceNoticeType = {}));
+function DeviceNoticeTypeToString(type) {
+    return type.toString();
+}
+function DeviceNoticeTypeFromString(type) {
+    const keys = Object.keys(DeviceNoticeType);
+    for (const key of keys) {
+        const s = DeviceNoticeTypeToString(DeviceNoticeType[key]);
+        if (s === type) {
+            return DeviceNoticeType[key];
+        }
+    }
+    return DeviceNoticeType.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceAccessKeyChanged.d.ts

@@ -0,0 +1,7 @@
+import { DeviceNotice } from '../DeviceNotice';
+export declare class DeviceAccessKeyChanged extends DeviceNotice {
+    did: string;
+    key: string;
+    constructor(timestamp: number, did: string, key: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceAccessKeyChanged.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceAccessKeyChanged = void 0;
+const DeviceNotice_1 = require("../DeviceNotice");
+const DeviceNoticeType_1 = require("../DeviceNoticeType");
+class DeviceAccessKeyChanged extends DeviceNotice_1.DeviceNotice {
+    constructor(timestamp, did, key) {
+        super(timestamp);
+        this.did = did;
+        this.key = key;
+    }
+    subType() {
+        return DeviceNoticeType_1.DeviceNoticeType.ACCESSKEY_CHANGED.toString();
+    }
+}
+exports.DeviceAccessKeyChanged = DeviceAccessKeyChanged;

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceChildrenAdded.d.ts

@@ -0,0 +1,8 @@
+import { DeviceNotice } from '../DeviceNotice';
+import { Device } from '../../../device/Device';
+export declare class DeviceChildrenAdded extends DeviceNotice {
+    did: string;
+    children: Device[];
+    constructor(timestamp: number, did: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceChildrenAdded.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceChildrenAdded = void 0;
+const DeviceNotice_1 = require("../DeviceNotice");
+const DeviceNoticeType_1 = require("../DeviceNoticeType");
+class DeviceChildrenAdded extends DeviceNotice_1.DeviceNotice {
+    constructor(timestamp, did) {
+        super(timestamp);
+        this.children = [];
+        this.did = did;
+    }
+    subType() {
+        return DeviceNoticeType_1.DeviceNoticeType.CHILDREN_ADDED.toString();
+    }
+}
+exports.DeviceChildrenAdded = DeviceChildrenAdded;

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceChildrenRemoved.d.ts

@@ -0,0 +1,7 @@
+import { DeviceNotice } from '../DeviceNotice';
+export declare class DeviceChildrenRemoved extends DeviceNotice {
+    did: string;
+    children: string[];
+    constructor(timestamp: number, did: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceChildrenRemoved.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceChildrenRemoved = void 0;
+const DeviceNotice_1 = require("../DeviceNotice");
+const DeviceNoticeType_1 = require("../DeviceNoticeType");
+class DeviceChildrenRemoved extends DeviceNotice_1.DeviceNotice {
+    constructor(timestamp, did) {
+        super(timestamp);
+        this.children = [];
+        this.did = did;
+    }
+    subType() {
+        return DeviceNoticeType_1.DeviceNoticeType.CHILDREN_REMOVED.toString();
+    }
+}
+exports.DeviceChildrenRemoved = DeviceChildrenRemoved;

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceEventOccurred.d.ts

@@ -0,0 +1,7 @@
+import { DeviceNotice } from '../DeviceNotice';
+import { EventOperation } from '../../../operation/EventOperation';
+export declare class DeviceEventOccurred extends DeviceNotice {
+    event: EventOperation;
+    constructor(timestamp: number, event: EventOperation);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/device/impl/DeviceEventOccurred.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceEventOccurred = void 0;
+const DeviceNotice_1 = require("../DeviceNotice");
+const DeviceNoticeType_1 = require("../DeviceNoticeType");
+class DeviceEventOccurred extends DeviceNotice_1.DeviceNotice {
+    constructor(timestamp, event) {
+        super(timestamp);
+        this.event = event;
+    }
+    subType() {
+        return DeviceNoticeType_1.DeviceNoticeType.EVENT_OCCURRED.toString();
+    }
+}
+exports.DeviceEventOccurred = DeviceEventOccurred;

package/dist/xiot/core/spec/typedef/notice/device/impl/DevicePropertiesChanged.d.ts

@@ -0,0 +1,7 @@
+import { DeviceNotice } from '../DeviceNotice';
+import { PropertyOperation } from '../../../operation/PropertyOperation';
+export declare class DevicePropertiesChanged extends DeviceNotice {
+    properties: PropertyOperation[];
+    constructor(timestamp: number, properties: PropertyOperation[]);
+    subType(): string;
+}