@openxiot/xiot-core-spec-ts 0.0.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/xiot/core/spec/typedef/oauth2/Oauth2Configuration.d.ts

@@ -0,0 +1,13 @@
+export declare class Oauth2Configuration {
+    platformId: string;
+    platformName: string;
+    clientId: string;
+    clientSecret: string;
+    callbackUrl: string;
+    accessTokenUrl: string;
+    profileUrl: string;
+    redirectUrl: string;
+    authorizeUrl: string;
+    icon: string;
+    available: boolean;
+}

package/dist/xiot/core/spec/typedef/oauth2/Oauth2Configuration.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Oauth2Configuration = void 0;
+class Oauth2Configuration {
+    constructor() {
+        this.platformId = 'unknown';
+        this.platformName = 'unknown';
+        this.clientId = '';
+        this.clientSecret = '';
+        this.callbackUrl = '';
+        this.accessTokenUrl = '';
+        this.profileUrl = '';
+        this.redirectUrl = '';
+        this.authorizeUrl = '';
+        this.icon = '';
+        this.available = true;
+    }
+}
+exports.Oauth2Configuration = Oauth2Configuration;

package/dist/xiot/core/spec/typedef/operation/AbstractOperation.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class AbstractOperation {
+    _message: any;
+    status: number;
+    description: string;
+    isError(): boolean;
+    isCompleted(): boolean;
+    isNotCompleted(): boolean;
+    abstract toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/AbstractOperation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractOperation = void 0;
+const Status_1 = require("../status/Status");
+class AbstractOperation {
+    constructor() {
+        this._message = {};
+        this.status = Status_1.Status.COMPLETED;
+        this.description = '';
+    }
+    isError() {
+        return this.status < 0;
+    }
+    isCompleted() {
+        return this.status === 0;
+    }
+    isNotCompleted() {
+        return this.status === Status_1.Status.TO_BE_EXECUTE;
+    }
+}
+exports.AbstractOperation = AbstractOperation;

package/dist/xiot/core/spec/typedef/operation/ActionOperation.d.ts

@@ -0,0 +1,17 @@
+import { AbstractOperation } from './AbstractOperation';
+import { ActionID } from '../xid/ActionID';
+import { ArgumentOperation } from './ArgumentOperation';
+export declare class ActionOperation extends AbstractOperation {
+    aid: ActionID;
+    oid: string;
+    in: Map<number, ArgumentOperation>;
+    out: Map<number, ArgumentOperation>;
+    argumentsCompact: boolean;
+    constructor();
+    error(status: number, description: string): ActionOperation;
+    getArgumentsIn(): ArgumentOperation[];
+    getArgumentsOut(): ArgumentOperation[];
+    setArgumentsIn(list: ArgumentOperation[]): void;
+    setArgumentsOut(list: ArgumentOperation[]): void;
+    toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/ActionOperation.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionOperation = void 0;
+const AbstractOperation_1 = require("./AbstractOperation");
+const ActionID_1 = require("../xid/ActionID");
+const ArgumentOperation_1 = require("./ArgumentOperation");
+class ActionOperation extends AbstractOperation_1.AbstractOperation {
+    constructor() {
+        super();
+        this.aid = new ActionID_1.ActionID();
+        this.oid = '';
+        this.in = new Map();
+        this.out = new Map();
+        this.argumentsCompact = false;
+    }
+    error(status, description) {
+        this.status = status;
+        this.description = description;
+        return this;
+    }
+    getArgumentsIn() {
+        return Array.from(this.in.values());
+    }
+    getArgumentsOut() {
+        return Array.from(this.out.values());
+    }
+    setArgumentsIn(list) {
+        list.forEach(x => {
+            return this.in.set(x.piid, x);
+        });
+    }
+    setArgumentsOut(list) {
+        list.forEach(x => {
+            return this.out.set(x.piid, x);
+        });
+    }
+    toString(pretty = true, tab = false) {
+        let str = '';
+        if (tab) {
+            str += '    ';
+        }
+        str += `${this.aid.toString()} =>`;
+        if (!pretty) {
+            str += ' ';
+        }
+        str += `${ArgumentOperation_1.ArgumentOperation.toString(this.in, pretty, tab)};`;
+        return str;
+    }
+}
+exports.ActionOperation = ActionOperation;

package/dist/xiot/core/spec/typedef/operation/ArgumentOperation.d.ts

@@ -0,0 +1,7 @@
+export declare class ArgumentOperation {
+    piid: number;
+    values: any[];
+    constructor(piid: number, values?: any[]);
+    toString(): string;
+    static toString(argumentList: Map<number, ArgumentOperation>, pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/ArgumentOperation.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentOperation = void 0;
+class ArgumentOperation {
+    constructor(piid, values = []) {
+        this.piid = piid;
+        this.values = values;
+    }
+    toString() {
+        let str = '#' + this.piid + ' = ';
+        for (let i = 0; i < this.values.length; i++) {
+            const value = this.values[i];
+            if ('string' === typeof value) {
+                str += `"${value}"`;
+            }
+            else {
+                str += value.toString();
+            }
+            if ((i + 1) < this.values.length) {
+                str += ', ';
+            }
+        }
+        return str;
+    }
+    static toString(argumentList, pretty = false, tab = false) {
+        let str = '', i = 1, size = argumentList.size;
+        if (pretty) {
+            str += `\n    `;
+            if (tab) {
+                str += '    ';
+            }
+        }
+        argumentList.forEach((o) => {
+            str += o.toString();
+            if (i < size) {
+                str += ',';
+                if (pretty) {
+                    str += `\n    `;
+                    if (tab) {
+                        str += '    ';
+                    }
+                }
+                else {
+                    str += ' ';
+                }
+            }
+            i++;
+        });
+        return str;
+    }
+}
+exports.ArgumentOperation = ArgumentOperation;

package/dist/xiot/core/spec/typedef/operation/EventOperation.d.ts

@@ -0,0 +1,16 @@
+import { AbstractOperation } from './AbstractOperation';
+import { EventID } from '../xid/EventID';
+import { ArgumentOperation } from './ArgumentOperation';
+export declare class EventOperation extends AbstractOperation {
+    eid: EventID;
+    oid: string;
+    readonly arguments: Map<number, ArgumentOperation>;
+    argumentsCompact: boolean;
+    getArgumentWithCheck(iid: number): ArgumentOperation;
+    getArguments(): ArgumentOperation[];
+    setArguments(list: ArgumentOperation[]): void;
+    iid(): number;
+    did(): string;
+    siid(): number;
+    toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/EventOperation.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventOperation = void 0;
+const AbstractOperation_1 = require("./AbstractOperation");
+const EventID_1 = require("../xid/EventID");
+const ArgumentOperation_1 = require("./ArgumentOperation");
+const Status_1 = require("../status/Status");
+const IotError_1 = require("../error/IotError");
+class EventOperation extends AbstractOperation_1.AbstractOperation {
+    constructor() {
+        super(...arguments);
+        this.eid = new EventID_1.EventID();
+        this.oid = '';
+        this.arguments = new Map();
+        this.argumentsCompact = false;
+    }
+    getArgumentWithCheck(iid) {
+        const arg = this.arguments.get(iid);
+        if (arg === undefined || arg === null) {
+            throw new IotError_1.IotError(Status_1.Status.UNDEFINED, `argument not found for ${iid}`);
+        }
+        if (arg.values.length === 0) {
+            throw new IotError_1.IotError(Status_1.Status.UNDEFINED, `argument values is empty for ${iid}`);
+        }
+        return arg;
+    }
+    getArguments() {
+        return Array.from(this.arguments.values());
+    }
+    setArguments(list) {
+        list.forEach(x => {
+            return this.arguments.set(x.piid, x);
+        });
+    }
+    iid() {
+        return this.eid.iid;
+    }
+    did() {
+        return this.eid.did;
+    }
+    siid() {
+        return this.eid.siid;
+    }
+    toString(pretty = false, tab = false) {
+        let str = '';
+        if (tab) {
+            str = '    ';
+        }
+        str += `${this.eid.toString()} =>`;
+        if (!pretty) {
+            str += ' ';
+        }
+        str += ArgumentOperation_1.ArgumentOperation.toString(this.arguments, pretty, tab);
+        str += ';';
+        return str;
+    }
+}
+exports.EventOperation = EventOperation;

package/dist/xiot/core/spec/typedef/operation/PropertyOperation.d.ts

@@ -0,0 +1,13 @@
+import { AbstractOperation } from './AbstractOperation';
+import { PropertyID } from '../xid/PropertyID';
+export declare class PropertyOperation extends AbstractOperation {
+    pid: PropertyID;
+    value: any | null;
+    argumentsCompact: boolean;
+    static create(pid: string): PropertyOperation;
+    error(status: number, description: string): PropertyOperation;
+    siid(): number;
+    iid(): number;
+    did(): string;
+    toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/PropertyOperation.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyOperation = void 0;
+const AbstractOperation_1 = require("./AbstractOperation");
+const PropertyID_1 = require("../xid/PropertyID");
+const Status_1 = require("../status/Status");
+const StringUtils_1 = require("../utils/StringUtils");
+class PropertyOperation extends AbstractOperation_1.AbstractOperation {
+    constructor() {
+        super(...arguments);
+        this.pid = new PropertyID_1.PropertyID();
+        this.value = null;
+        this.argumentsCompact = false;
+    }
+    static create(pid) {
+        const o = new PropertyOperation();
+        o.pid = PropertyID_1.PropertyID.parse(pid);
+        if (!o.pid.valid) {
+            o.status = Status_1.Status.PID_INVALID;
+        }
+        return o;
+    }
+    error(status, description) {
+        this.status = status;
+        this.description = description;
+        return this;
+    }
+    siid() {
+        return this.pid.siid;
+    }
+    iid() {
+        return this.pid.iid;
+    }
+    did() {
+        return this.pid.did;
+    }
+    toString(pretty, tab) {
+        let str = '';
+        if (tab) {
+            str += '    ';
+        }
+        str += `${this.pid.toString()} => `;
+        if ((0, StringUtils_1.isString)(this.value)) {
+            str += `"${this.value}"`;
+        }
+        else {
+            str += this.value.toString();
+        }
+        str += ';';
+        return str;
+    }
+}
+exports.PropertyOperation = PropertyOperation;

package/dist/xiot/core/spec/typedef/operation/RemindOperation.d.ts

@@ -0,0 +1,7 @@
+import { AbstractOperation } from './AbstractOperation';
+export declare class RemindOperation extends AbstractOperation {
+    private _text;
+    get text(): string;
+    set text(value: string);
+    toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/RemindOperation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemindOperation = void 0;
+const AbstractOperation_1 = require("./AbstractOperation");
+class RemindOperation extends AbstractOperation_1.AbstractOperation {
+    constructor() {
+        super(...arguments);
+        this._text = '';
+    }
+    get text() {
+        return this._text;
+    }
+    set text(value) {
+        this._text = value;
+    }
+    toString(pretty = true, tab = false) {
+        let str = '';
+        if (tab) {
+            str += '    ';
+        }
+        str += `REMIND => "${this.text}";`;
+        return str;
+    }
+}
+exports.RemindOperation = RemindOperation;

package/dist/xiot/core/spec/typedef/operation/RuleOperation.d.ts

@@ -0,0 +1,8 @@
+import { AbstractOperation } from './AbstractOperation';
+export declare class RuleOperation extends AbstractOperation {
+    private _ruleId;
+    constructor(ruleId: string);
+    get ruleId(): string;
+    set ruleId(value: string);
+    toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/RuleOperation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleOperation = void 0;
+const AbstractOperation_1 = require("./AbstractOperation");
+class RuleOperation extends AbstractOperation_1.AbstractOperation {
+    constructor(ruleId) {
+        super();
+        this._ruleId = ruleId;
+    }
+    get ruleId() {
+        return this._ruleId;
+    }
+    set ruleId(value) {
+        this._ruleId = value;
+    }
+    toString(pretty = true, tab = false) {
+        let str = '';
+        if (tab) {
+            str += '    ';
+        }
+        str += `@${this.ruleId};`;
+        return str;
+    }
+}
+exports.RuleOperation = RuleOperation;

package/dist/xiot/core/spec/typedef/operation/SleepOperation.d.ts

@@ -0,0 +1,7 @@
+import { AbstractOperation } from './AbstractOperation';
+export declare class SleepOperation extends AbstractOperation {
+    private _seconds;
+    get seconds(): number;
+    set seconds(value: number);
+    toString(pretty?: boolean, tab?: boolean): string;
+}

package/dist/xiot/core/spec/typedef/operation/SleepOperation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SleepOperation = void 0;
+const AbstractOperation_1 = require("./AbstractOperation");
+class SleepOperation extends AbstractOperation_1.AbstractOperation {
+    constructor() {
+        super(...arguments);
+        this._seconds = 0;
+    }
+    get seconds() {
+        return this._seconds;
+    }
+    set seconds(value) {
+        this._seconds = value;
+    }
+    toString(pretty = true, tab = false) {
+        let str = '';
+        if (tab) {
+            str += '    ';
+        }
+        str += `SLEEP => ${this.seconds};`;
+        return str;
+    }
+}
+exports.SleepOperation = SleepOperation;

package/dist/xiot/core/spec/typedef/operation/value/AnyValue.d.ts

@@ -0,0 +1,3 @@
+export declare class AnyValue {
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/operation/value/AnyValue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyValue = void 0;
+class AnyValue {
+    toString() {
+        return 'ANY';
+    }
+}
+exports.AnyValue = AnyValue;

package/dist/xiot/core/spec/typedef/operation/value/AutoscalingValue.d.ts

@@ -0,0 +1,3 @@
+export declare class AutoscalingValue {
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/operation/value/AutoscalingValue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoscalingValue = void 0;
+class AutoscalingValue {
+    toString() {
+        return 'AUTOSCALING';
+    }
+}
+exports.AutoscalingValue = AutoscalingValue;

package/dist/xiot/core/spec/typedef/operation/value/ReverseValue.d.ts

@@ -0,0 +1,3 @@
+export declare class ReverseValue {
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/operation/value/ReverseValue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReverseValue = void 0;
+class ReverseValue {
+    toString() {
+        return 'REVERSE';
+    }
+}
+exports.ReverseValue = ReverseValue;

package/dist/xiot/core/spec/typedef/ownership/DeviceOwner.d.ts

@@ -0,0 +1,4 @@
+export declare class DeviceOwner {
+    appId: string;
+    ownerId: string;
+}

package/dist/xiot/core/spec/typedef/ownership/DeviceOwner.js

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

package/dist/xiot/core/spec/typedef/ownership/Ownership.d.ts

@@ -0,0 +1,12 @@
+export declare class Ownership {
+    appId: string;
+    ownerId: string;
+    did: string;
+    token: string;
+    rootId: string;
+    cloudId: string;
+    createAt: Date;
+    updateAt: Date;
+    createAtString(): string;
+    updateAtString(): string;
+}

package/dist/xiot/core/spec/typedef/ownership/Ownership.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ownership = void 0;
+class Ownership {
+    constructor() {
+        this.appId = '';
+        this.ownerId = '';
+        this.did = '';
+        this.token = '';
+        this.rootId = '';
+        this.cloudId = '';
+    }
+    createAtString() {
+        if (this.createAt === undefined) {
+            return '';
+        }
+        return `${this.createAt.getFullYear()}-${this.createAt.getMonth() + 1}-${this.createAt.getDate()} ${this.createAt.getHours()}:${this.createAt.getMinutes()}`;
+    }
+    updateAtString() {
+        if (this.updateAt === undefined) {
+            return '';
+        }
+        return `${this.updateAt.getFullYear()}-${this.updateAt.getMonth() + 1}-${this.updateAt.getDate()} ${this.updateAt.getHours()}:${this.updateAt.getMinutes()}`;
+    }
+}
+exports.Ownership = Ownership;