@openxiot/xiot-core-spec-ts 0.0.2

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

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

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePropertyChanged = void 0;
+const DeviceNotice_1 = require("../DeviceNotice");
+const DeviceNoticeType_1 = require("../DeviceNoticeType");
+const PropertyOperation_1 = require("../../../operation/PropertyOperation");
+class DevicePropertyChanged extends DeviceNotice_1.DeviceNotice {
+    constructor(timestamp, property) {
+        super(timestamp);
+        this.property = new PropertyOperation_1.PropertyOperation();
+        this.property = property;
+    }
+    subType() {
+        return DeviceNoticeType_1.DeviceNoticeType.PROPERTY_CHANGED.toString();
+    }
+}
+exports.DevicePropertyChanged = DevicePropertyChanged;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceSummaryChanged = void 0;
+const DeviceNotice_1 = require("../DeviceNotice");
+const DeviceNoticeType_1 = require("../DeviceNoticeType");
+const Summary_1 = require("../../../summary/Summary");
+class DeviceSummaryChanged extends DeviceNotice_1.DeviceNotice {
+    constructor(timestamp, did) {
+        super(timestamp);
+        this.summary = new Summary_1.Summary();
+        this.did = did;
+    }
+    subType() {
+        return DeviceNoticeType_1.DeviceNoticeType.SUMMARY_CHANGED.toString();
+    }
+}
+exports.DeviceSummaryChanged = DeviceSummaryChanged;

package/dist/xiot/core/spec/typedef/notice/owner/OwnerNotice.d.ts

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

package/dist/xiot/core/spec/typedef/notice/owner/OwnerNotice.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerNotice = void 0;
+const Notice_1 = require("../Notice");
+class OwnerNotice extends Notice_1.Notice {
+    constructor(timestamp, appId, ownerId, userId) {
+        super(timestamp);
+        this.appId = appId;
+        this.ownerId = ownerId;
+        this.userId = userId;
+    }
+    mainType() {
+        return 'owner';
+    }
+}
+exports.OwnerNotice = OwnerNotice;

package/dist/xiot/core/spec/typedef/notice/owner/OwnerNoticeType.d.ts

@@ -0,0 +1,42 @@
+export declare enum OwnerNoticeType {
+    UNDEFINED = "undefined",
+    DEVICE_ADDED = "device-added",
+    DEVICE_REMOVED = "device-removed",
+    DEVICE_SUMMARY_CHANGED = "device-summary-changed",
+    DEVICE_SOMEWHERE_CHANGED = "device-somewhere-changed",
+    DEVICE_PROPERTIES_CHANGED = "device-properties-changed",
+    DEVICE_EVENT_OCCURRED = "device-event-occurred",
+    OWNERSHIP_TAKEN = "ownership-taken",
+    OWNERSHIP_DISCLAIMED = "ownership-disclaimed",
+    RULE_ADDED = "rule-added",
+    RULE_REMOVED = "rule-removed",
+    RULE_CHANGED = "rule-changed",
+    RULE_TRIGGERED = "rule-triggered",
+    RULE_EXECUTED = "rule-executed",
+    /**
+     * home added
+     */
+    HOME_ADDED = "home-added",
+    /**
+     * home removed
+     */
+    HOME_REMOVED = "home-removed",
+    /**
+     * home changed
+     */
+    HOME_CHANGED = "home-changed",
+    /**
+     * space added
+     */
+    SPACE_ADDED = "space-added",
+    /**
+     * space removed
+     */
+    SPACE_REMOVED = "space-removed",
+    /**
+     * space changed
+     */
+    SPACE_CHANGED = "space-changed"
+}
+export declare function OwnerNoticeTypeToString(type: OwnerNoticeType): string;
+export declare function OwnerNoticeTypeFromString(type: string): OwnerNoticeType;

package/dist/xiot/core/spec/typedef/notice/owner/OwnerNoticeType.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerNoticeType = void 0;
+exports.OwnerNoticeTypeToString = OwnerNoticeTypeToString;
+exports.OwnerNoticeTypeFromString = OwnerNoticeTypeFromString;
+var OwnerNoticeType;
+(function (OwnerNoticeType) {
+    OwnerNoticeType["UNDEFINED"] = "undefined";
+    OwnerNoticeType["DEVICE_ADDED"] = "device-added";
+    OwnerNoticeType["DEVICE_REMOVED"] = "device-removed";
+    OwnerNoticeType["DEVICE_SUMMARY_CHANGED"] = "device-summary-changed";
+    OwnerNoticeType["DEVICE_SOMEWHERE_CHANGED"] = "device-somewhere-changed";
+    OwnerNoticeType["DEVICE_PROPERTIES_CHANGED"] = "device-properties-changed";
+    OwnerNoticeType["DEVICE_EVENT_OCCURRED"] = "device-event-occurred";
+    OwnerNoticeType["OWNERSHIP_TAKEN"] = "ownership-taken";
+    OwnerNoticeType["OWNERSHIP_DISCLAIMED"] = "ownership-disclaimed";
+    OwnerNoticeType["RULE_ADDED"] = "rule-added";
+    OwnerNoticeType["RULE_REMOVED"] = "rule-removed";
+    OwnerNoticeType["RULE_CHANGED"] = "rule-changed";
+    OwnerNoticeType["RULE_TRIGGERED"] = "rule-triggered";
+    OwnerNoticeType["RULE_EXECUTED"] = "rule-executed";
+    /**
+     * home added
+     */
+    OwnerNoticeType["HOME_ADDED"] = "home-added";
+    /**
+     * home removed
+     */
+    OwnerNoticeType["HOME_REMOVED"] = "home-removed";
+    /**
+     * home changed
+     */
+    OwnerNoticeType["HOME_CHANGED"] = "home-changed";
+    /**
+     * space added
+     */
+    OwnerNoticeType["SPACE_ADDED"] = "space-added";
+    /**
+     * space removed
+     */
+    OwnerNoticeType["SPACE_REMOVED"] = "space-removed";
+    /**
+     * space changed
+     */
+    OwnerNoticeType["SPACE_CHANGED"] = "space-changed";
+})(OwnerNoticeType || (exports.OwnerNoticeType = OwnerNoticeType = {}));
+function OwnerNoticeTypeToString(type) {
+    return type.toString();
+}
+function OwnerNoticeTypeFromString(type) {
+    const keys = Object.keys(OwnerNoticeType);
+    for (const key of keys) {
+        const s = OwnerNoticeTypeToString(OwnerNoticeType[key]);
+        if (s === type) {
+            return OwnerNoticeType[key];
+        }
+    }
+    return OwnerNoticeType.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceAdded.d.ts

@@ -0,0 +1,10 @@
+import { OwnerNotice } from '../OwnerNotice';
+import { Summary } from '../../../summary/Summary';
+import { Somewhere } from "../../../somewhere/Somewhere";
+export declare class OwnerDeviceAdded extends OwnerNotice {
+    did: string;
+    summary: Summary;
+    somewhere: Somewhere;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, did: string, summary: Summary, somewhere: Somewhere);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceAdded.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerDeviceAdded = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerDeviceAdded extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, did, summary, somewhere) {
+        super(timestamp, appId, ownerId, userId);
+        this.did = did;
+        this.summary = summary;
+        this.somewhere = somewhere;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.DEVICE_ADDED.toString();
+    }
+}
+exports.OwnerDeviceAdded = OwnerDeviceAdded;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceRemoved.d.ts

@@ -0,0 +1,6 @@
+import { OwnerNotice } from '../OwnerNotice';
+export declare class OwnerDeviceRemoved extends OwnerNotice {
+    did: string;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, did: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceRemoved.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerDeviceRemoved = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerDeviceRemoved extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, did) {
+        super(timestamp, appId, ownerId, userId);
+        this.did = did;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.DEVICE_REMOVED.toString();
+    }
+}
+exports.OwnerDeviceRemoved = OwnerDeviceRemoved;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceSomewhereChanged.d.ts

@@ -0,0 +1,8 @@
+import { OwnerNotice } from '../OwnerNotice';
+import { Somewhere } from "../../../somewhere/Somewhere";
+export declare class OwnerDeviceSomewhereChanged extends OwnerNotice {
+    did: string;
+    somewhere: Somewhere;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, did: string, somewhere: Somewhere);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceSomewhereChanged.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerDeviceSomewhereChanged = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerDeviceSomewhereChanged extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, did, somewhere) {
+        super(timestamp, appId, ownerId, userId);
+        this.did = did;
+        this.somewhere = somewhere;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.DEVICE_SOMEWHERE_CHANGED.toString();
+    }
+}
+exports.OwnerDeviceSomewhereChanged = OwnerDeviceSomewhereChanged;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceSummaryChanged.d.ts

@@ -0,0 +1,8 @@
+import { OwnerNotice } from '../OwnerNotice';
+import { Summary } from '../../../summary/Summary';
+export declare class OwnerDeviceSummaryChanged extends OwnerNotice {
+    did: string;
+    summary: Summary;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, did: string, summary: Summary);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerDeviceSummaryChanged.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerDeviceSummaryChanged = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerDeviceSummaryChanged extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, did, summary) {
+        super(timestamp, appId, ownerId, userId);
+        this.did = did;
+        this.summary = summary;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.DEVICE_SUMMARY_CHANGED.toString();
+    }
+}
+exports.OwnerDeviceSummaryChanged = OwnerDeviceSummaryChanged;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerEventOccurred.d.ts

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

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerEventOccurred.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerEventOccurred = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerEventOccurred extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, event) {
+        super(timestamp, appId, ownerId, userId);
+        this.event = event;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.DEVICE_EVENT_OCCURRED.toString();
+    }
+}
+exports.OwnerEventOccurred = OwnerEventOccurred;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerPropertiesChanged.d.ts

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

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerPropertiesChanged.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerPropertiesChanged = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerPropertiesChanged extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, properties) {
+        super(timestamp, appId, ownerId, userId);
+        this.properties = properties;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.DEVICE_PROPERTIES_CHANGED.toString();
+    }
+}
+exports.OwnerPropertiesChanged = OwnerPropertiesChanged;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleAdded.d.ts

@@ -0,0 +1,7 @@
+import { OwnerNotice } from '../OwnerNotice';
+import { Rule } from '../../../rule/Rule';
+export declare class OwnerRuleAdded extends OwnerNotice {
+    rule: Rule;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, rule: Rule);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleAdded.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerRuleAdded = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerRuleAdded extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, rule) {
+        super(timestamp, appId, ownerId, userId);
+        this.rule = rule;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.RULE_ADDED.toString();
+    }
+}
+exports.OwnerRuleAdded = OwnerRuleAdded;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleChanged.d.ts

@@ -0,0 +1,7 @@
+import { OwnerNotice } from '../OwnerNotice';
+import { Rule } from '../../../rule/Rule';
+export declare class OwnerRuleChanged extends OwnerNotice {
+    rule: Rule;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, rule: Rule);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleChanged.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerRuleChanged = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerRuleChanged extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, rule) {
+        super(timestamp, appId, ownerId, userId);
+        this.rule = rule;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.RULE_CHANGED.toString();
+    }
+}
+exports.OwnerRuleChanged = OwnerRuleChanged;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleExecuted.d.ts

@@ -0,0 +1,8 @@
+import { OwnerNotice } from '../OwnerNotice';
+import { AbstractOperation } from '../../../operation/AbstractOperation';
+export declare class OwnerRuleExecuted extends OwnerNotice {
+    ruleId: string;
+    operations: AbstractOperation[];
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, ruleId: string, operations: AbstractOperation[]);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleExecuted.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerRuleExecuted = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerRuleExecuted extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, ruleId, operations) {
+        super(timestamp, appId, ownerId, userId);
+        this.ruleId = ruleId;
+        this.operations = operations;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.RULE_EXECUTED.toString();
+    }
+}
+exports.OwnerRuleExecuted = OwnerRuleExecuted;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleRemoved.d.ts

@@ -0,0 +1,6 @@
+import { OwnerNotice } from '../OwnerNotice';
+export declare class OwnerRuleRemoved extends OwnerNotice {
+    ruleId: string;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, ruleId: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleRemoved.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerRuleRemoved = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerRuleRemoved extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, ruleId) {
+        super(timestamp, appId, ownerId, userId);
+        this.ruleId = ruleId;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.RULE_REMOVED.toString();
+    }
+}
+exports.OwnerRuleRemoved = OwnerRuleRemoved;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleTriggered.d.ts

@@ -0,0 +1,6 @@
+import { OwnerNotice } from '../OwnerNotice';
+export declare class OwnerRuleTriggered extends OwnerNotice {
+    ruleId: string;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, ruleId: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnerRuleTriggered.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerRuleTriggered = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnerRuleTriggered extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, ruleId) {
+        super(timestamp, appId, ownerId, userId);
+        this.ruleId = ruleId;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.RULE_TRIGGERED.toString();
+    }
+}
+exports.OwnerRuleTriggered = OwnerRuleTriggered;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnershipDisclaimed.d.ts

@@ -0,0 +1,6 @@
+import { OwnerNotice } from '../OwnerNotice';
+export declare class OwnershipDisclaimed extends OwnerNotice {
+    did: string;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, did: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnershipDisclaimed.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnershipDisclaimed = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnershipDisclaimed extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, did) {
+        super(timestamp, appId, ownerId, userId);
+        this.did = did;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.OWNERSHIP_DISCLAIMED.toString();
+    }
+}
+exports.OwnershipDisclaimed = OwnershipDisclaimed;

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnershipTaken.d.ts

@@ -0,0 +1,6 @@
+import { OwnerNotice } from '../OwnerNotice';
+export declare class OwnershipTaken extends OwnerNotice {
+    did: string;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, did: string);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/OwnershipTaken.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnershipTaken = void 0;
+const OwnerNotice_1 = require("../OwnerNotice");
+const OwnerNoticeType_1 = require("../OwnerNoticeType");
+class OwnershipTaken extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, did) {
+        super(timestamp, appId, ownerId, userId);
+        this.did = did;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.OWNERSHIP_TAKEN.toString();
+    }
+}
+exports.OwnershipTaken = OwnershipTaken;

package/dist/xiot/core/spec/typedef/notice/owner/impl/home/OwnerHomeAdded.d.ts

@@ -0,0 +1,7 @@
+import { OwnerNotice } from '../../OwnerNotice';
+import { Space } from "../../../../space/Space";
+export declare class OwnerHomeAdded extends OwnerNotice {
+    home: Space;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, home: Space);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/home/OwnerHomeAdded.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerHomeAdded = void 0;
+const OwnerNotice_1 = require("../../OwnerNotice");
+const OwnerNoticeType_1 = require("../../OwnerNoticeType");
+class OwnerHomeAdded extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, home) {
+        super(timestamp, appId, ownerId, userId);
+        this.home = home;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.HOME_ADDED.toString();
+    }
+}
+exports.OwnerHomeAdded = OwnerHomeAdded;

package/dist/xiot/core/spec/typedef/notice/owner/impl/home/OwnerHomeChanged.d.ts

@@ -0,0 +1,7 @@
+import { OwnerNotice } from '../../OwnerNotice';
+import { Space } from "../../../../space/Space";
+export declare class OwnerHomeChanged extends OwnerNotice {
+    home: Space;
+    constructor(timestamp: number, appId: string, ownerId: string, userId: string, home: Space);
+    subType(): string;
+}

package/dist/xiot/core/spec/typedef/notice/owner/impl/home/OwnerHomeChanged.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerHomeChanged = void 0;
+const OwnerNotice_1 = require("../../OwnerNotice");
+const OwnerNoticeType_1 = require("../../OwnerNoticeType");
+class OwnerHomeChanged extends OwnerNotice_1.OwnerNotice {
+    constructor(timestamp, appId, ownerId, userId, home) {
+        super(timestamp, appId, ownerId, userId);
+        this.home = home;
+    }
+    subType() {
+        return OwnerNoticeType_1.OwnerNoticeType.HOME_CHANGED.toString();
+    }
+}
+exports.OwnerHomeChanged = OwnerHomeChanged;