@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/codec/shadow/ShadowCodec.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShadowCodec = void 0;
+const Shadow_1 = require("../../typedef/shadow/Shadow");
+const Spec_1 = require("../../typedef/constant/Spec");
+class ShadowCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                array.push(ShadowCodec.decodeObject(o));
+            }
+        }
+        return array;
+    }
+    static decodeObject(o) {
+        const shadow = new Shadow_1.Shadow();
+        shadow.siid = o[Spec_1.Spec.SIID] || 0;
+        shadow.piid = o[Spec_1.Spec.PIID] || 0;
+        shadow.status = o[Spec_1.Spec.STATUS] || 0;
+        if (shadow.status >= 0) {
+            shadow.value = o[Spec_1.Spec.VALUE];
+        }
+        else {
+            shadow.description = o[Spec_1.Spec.DESCRIPTION] || '';
+        }
+        return shadow;
+    }
+    static encodeObject(s) {
+        const o = {
+            siid: s.siid,
+            piid: s.piid,
+            status: s.status
+        };
+        if (s.status >= 0) {
+            o[Spec_1.Spec.VALUE] = s.value;
+        }
+        else {
+            o[Spec_1.Spec.DESCRIPTION] = s.description;
+        }
+        return o;
+    }
+    static encodeArray(array) {
+        return array != null
+            ? array.map(s => {
+                return ShadowCodec.encodeObject(s);
+            })
+            : [];
+    }
+}
+exports.ShadowCodec = ShadowCodec;

package/dist/xiot/core/spec/codec/somewhere/SomewhereCodec.d.ts

@@ -0,0 +1,7 @@
+import { Somewhere } from '../../typedef/somewhere/Somewhere';
+export declare class SomewhereCodec {
+    static decodeArray(list: any[]): Somewhere[];
+    static decodeObject(o: any): Somewhere;
+    static encodeObject(s: Somewhere): any;
+    static encodeArray(array: Array<Somewhere>): any[];
+}

package/dist/xiot/core/spec/codec/somewhere/SomewhereCodec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SomewhereCodec = void 0;
+const Somewhere_1 = require("../../typedef/somewhere/Somewhere");
+const Where_1 = require("../../typedef/somewhere/Where");
+class SomewhereCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                array.push(SomewhereCodec.decodeObject(o));
+            }
+        }
+        return array;
+    }
+    static decodeObject(o) {
+        const somewhere = new Somewhere_1.Somewhere();
+        if (o.where !== undefined) {
+            somewhere.where = (0, Where_1.WhereFromString)(o.where);
+        }
+        if (o.spaceId !== undefined) {
+            somewhere.spaceId = o.spaceId;
+        }
+        if (o.index !== 0) {
+            somewhere.index = o.index;
+        }
+        return somewhere;
+    }
+    static encodeObject(s) {
+        const o = {};
+        if (s.spaceId != null) {
+            o.spaceId = s.spaceId;
+        }
+        if (s.where != Where_1.Where.UNKNOWN) {
+            o.where = s.where.toString();
+        }
+        if (s.index !== 0) {
+            o.index = s.index;
+        }
+        return o;
+    }
+    static encodeArray(array) {
+        return array != null
+            ? array.map(s => {
+                return SomewhereCodec.encodeObject(s);
+            })
+            : [];
+    }
+}
+exports.SomewhereCodec = SomewhereCodec;

package/dist/xiot/core/spec/codec/space/SpaceCodec.d.ts

@@ -0,0 +1,7 @@
+import { Space } from "../../typedef/space/Space";
+export declare class SpaceCodec {
+    static decodeArray(list: any[]): Space[];
+    static decodeObject(o: any): Space;
+    static encodeObject(s: Space): any;
+    static encodeArray(array: Array<Space>): any[];
+}

package/dist/xiot/core/spec/codec/space/SpaceCodec.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceCodec = void 0;
+const Space_1 = require("../../typedef/space/Space");
+class SpaceCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                array.push(SpaceCodec.decodeObject(o));
+            }
+        }
+        return array;
+    }
+    static decodeObject(o) {
+        const x = new Space_1.Space(o['id'] || '');
+        x.name = o['name'] || '';
+        x.rootId = o['rootId'] || null;
+        x.parentId = o['parentId'] || null;
+        x.index = o['index'] || 0;
+        return x;
+    }
+    static encodeObject(s) {
+        const o = {
+            id: s.id,
+            name: s.name,
+            index: s.index
+        };
+        if (s.rootId !== null) {
+            o['rootId'] = s.rootId;
+        }
+        if (s.parentId !== null) {
+            o['parentId'] = s.parentId;
+        }
+        return o;
+    }
+    static encodeArray(array) {
+        return array != null
+            ? array.map(s => {
+                return SpaceCodec.encodeObject(s);
+            })
+            : [];
+    }
+}
+exports.SpaceCodec = SpaceCodec;

package/dist/xiot/core/spec/codec/summary/SummaryCodec.d.ts

@@ -0,0 +1,7 @@
+import { Summary } from '../../typedef/summary/Summary';
+export declare class SummaryCodec {
+    static decodeArray(list: any[]): Summary[];
+    static decodeObject(o: any): Summary;
+    static encodeObject(s: Summary): any;
+    static encodeArray(array: Array<Summary>): any[];
+}

package/dist/xiot/core/spec/codec/summary/SummaryCodec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryCodec = void 0;
+const Summary_1 = require("../../typedef/summary/Summary");
+const Urn_1 = require("../../typedef/definition/urn/Urn");
+const UrnType_1 = require("../../typedef/definition/urn/UrnType");
+class SummaryCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                array.push(SummaryCodec.decodeObject(o));
+            }
+        }
+        return array;
+    }
+    static decodeObject(o) {
+        const summary = new Summary_1.Summary();
+        summary.type = new Urn_1.Urn([UrnType_1.UrnType.DEVICE, UrnType_1.UrnType.GROUP], o.type);
+        summary.online = o.online;
+        if (o.members !== undefined) {
+            summary.members = o.members;
+        }
+        if (o.cloudId !== undefined) {
+            summary.cloudId = o.cloudId;
+        }
+        if (o.parentId !== undefined) {
+            summary.parentId = o.parentId;
+        }
+        if (o.rootId !== undefined) {
+            summary.rootId = o.rootId;
+        }
+        if (o.protocol !== undefined) {
+            summary.protocol = o.protocol;
+        }
+        if (o.lastOnline !== undefined) {
+            summary.lastOnline = new Date(o.lastOnline);
+        }
+        if (o.lastOffline !== undefined) {
+            summary.lastOffline = new Date(o.lastOffline);
+        }
+        return summary;
+    }
+    static encodeObject(s) {
+        const o = {
+            type: s.type != null ? s.type.toString() : '',
+            online: s.online
+        };
+        if (s.parentId != null) {
+            o.parentId = s.parentId;
+        }
+        if (s.cloudId != null) {
+            o.cloudId = s.cloudId;
+        }
+        if (s.members != null) {
+            if (s.members.length > 0) {
+                o.members = s.members;
+            }
+        }
+        if (s.rootId != null) {
+            o.rootId = s.rootId;
+        }
+        if (s.protocol != null) {
+            o.protocol = s.protocol;
+        }
+        if (s.lastOnline !== undefined) {
+            o.lastOnline = s.lastOnline.getTime();
+        }
+        if (s.lastOffline !== undefined) {
+            o.lastOffline = s.lastOffline.getTime();
+        }
+        return o;
+    }
+    static encodeArray(array) {
+        return array != null
+            ? array.map(s => {
+                return SummaryCodec.encodeObject(s);
+            })
+            : [];
+    }
+}
+exports.SummaryCodec = SummaryCodec;

package/dist/xiot/core/spec/codec/template/ActionTemplateCodec.d.ts

@@ -0,0 +1,7 @@
+import { ActionTemplate } from '../../typedef/template/ActionTemplate';
+export declare class ActionTemplateCodec {
+    static decodeArray(array: any[]): ActionTemplate[];
+    static decode(o: any): ActionTemplate;
+    static encode(template: ActionTemplate): any;
+    static encodeArray(actions: Map<number, ActionTemplate>): any[];
+}

package/dist/xiot/core/spec/codec/template/ActionTemplateCodec.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionTemplateCodec = void 0;
+const ActionTemplate_1 = require("../../typedef/template/ActionTemplate");
+const Spec_1 = require("../../typedef/constant/Spec");
+const ActionType_1 = require("../../typedef/definition/urn/ActionType");
+const DescriptionCodec_1 = require("../definition/DescriptionCodec");
+const ArgumentCodec_1 = require("../instance/ArgumentCodec");
+class ActionTemplateCodec {
+    static decodeArray(array) {
+        const list = [];
+        if (array != null) {
+            for (const o of array) {
+                list.push(ActionTemplateCodec.decode(o));
+            }
+        }
+        return list;
+    }
+    static decode(o) {
+        const iid = o[Spec_1.Spec.IID];
+        const required = o[Spec_1.Spec.X_REQUIRED];
+        const source = o[Spec_1.Spec.X_SOURCE];
+        const type = new ActionType_1.ActionType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const argumentsIn = ArgumentCodec_1.ArgumentCodec.decodeArray(o[Spec_1.Spec.IN]);
+        const argumentsOut = ArgumentCodec_1.ArgumentCodec.decodeArray(o[Spec_1.Spec.OUT]);
+        return new ActionTemplate_1.ActionTemplate(iid, required, type, description, argumentsIn, argumentsOut, source);
+    }
+    static encode(template) {
+        const o = {
+            iid: template.iid,
+            type: template.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(template.description)
+        };
+        o[Spec_1.Spec.X_REQUIRED] = template.required;
+        if (template.source) {
+            o[Spec_1.Spec.X_SOURCE] = template.source;
+        }
+        if (template.in.size > 0) {
+            o[Spec_1.Spec.IN] = ArgumentCodec_1.ArgumentCodec.encodeArray(template.getArgumentsIn());
+        }
+        if (template.out.size > 0) {
+            o[Spec_1.Spec.OUT] = ArgumentCodec_1.ArgumentCodec.encodeArray(template.getArgumentsOut());
+        }
+        return o;
+    }
+    static encodeArray(actions) {
+        const array = [];
+        actions.forEach((action, iid) => {
+            array.push(ActionTemplateCodec.encode(action));
+        });
+        return array;
+    }
+}
+exports.ActionTemplateCodec = ActionTemplateCodec;

package/dist/xiot/core/spec/codec/template/DeviceTemplateCodec.d.ts

@@ -0,0 +1,5 @@
+import { DeviceTemplate } from '../../typedef/template/DeviceTemplate';
+export declare class DeviceTemplateCodec {
+    static decode(o: any): DeviceTemplate;
+    static encode(device: DeviceTemplate): any;
+}

package/dist/xiot/core/spec/codec/template/DeviceTemplateCodec.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTemplateCodec = void 0;
+const DeviceTemplate_1 = require("../../typedef/template/DeviceTemplate");
+const DeviceType_1 = require("../../typedef/definition/urn/DeviceType");
+const DescriptionCodec_1 = require("../definition/DescriptionCodec");
+const Spec_1 = require("../../typedef/constant/Spec");
+const ServiceTemplateCodec_1 = require("./ServiceTemplateCodec");
+class DeviceTemplateCodec {
+    static decode(o) {
+        const type = new DeviceType_1.DeviceType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const services = ServiceTemplateCodec_1.ServiceTemplateCodec.decodeArray(o[Spec_1.Spec.SERVICES]);
+        return new DeviceTemplate_1.DeviceTemplate(type, description, services);
+    }
+    static encode(device) {
+        return {
+            type: device.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(device.description),
+            services: ServiceTemplateCodec_1.ServiceTemplateCodec.encodeArray(device.services)
+        };
+    }
+}
+exports.DeviceTemplateCodec = DeviceTemplateCodec;

package/dist/xiot/core/spec/codec/template/EventTemplateCodec.d.ts

@@ -0,0 +1,7 @@
+import { EventTemplate } from '../../typedef/template/EventTemplate';
+export declare class EventTemplateCodec {
+    static decodeArray(array: any[]): EventTemplate[];
+    static decode(o: any): EventTemplate;
+    static encode(event: EventTemplate): any;
+    static encodeArray(events: Map<number, EventTemplate>): any[];
+}

package/dist/xiot/core/spec/codec/template/EventTemplateCodec.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTemplateCodec = void 0;
+const EventTemplate_1 = require("../../typedef/template/EventTemplate");
+const Spec_1 = require("../../typedef/constant/Spec");
+const EventType_1 = require("../../typedef/definition/urn/EventType");
+const DescriptionCodec_1 = require("../definition/DescriptionCodec");
+const ArgumentCodec_1 = require("../instance/ArgumentCodec");
+class EventTemplateCodec {
+    static decodeArray(array) {
+        const list = [];
+        if (array != null) {
+            for (const o of array) {
+                list.push(EventTemplateCodec.decode(o));
+            }
+        }
+        return list;
+    }
+    static decode(o) {
+        const iid = o[Spec_1.Spec.IID];
+        const required = o[Spec_1.Spec.X_REQUIRED];
+        const source = o[Spec_1.Spec.X_SOURCE];
+        const type = new EventType_1.EventType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const a = ArgumentCodec_1.ArgumentCodec.decodeArray(o[Spec_1.Spec.ARGUMENTS]);
+        return new EventTemplate_1.EventTemplate(iid, required, type, description, a, source);
+    }
+    static encode(event) {
+        const o = {
+            iid: event.iid,
+            type: event.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(event.description)
+        };
+        o[Spec_1.Spec.X_REQUIRED] = event.required;
+        if (event.source) {
+            o[Spec_1.Spec.X_SOURCE] = event.source;
+        }
+        if (event.arguments.size > 0) {
+            o[Spec_1.Spec.ARGUMENTS] = ArgumentCodec_1.ArgumentCodec.encodeArray(event.getArguments());
+        }
+        return o;
+    }
+    static encodeArray(events) {
+        const array = [];
+        events.forEach((event, iid) => {
+            array.push(EventTemplateCodec.encode(event));
+        });
+        return array;
+    }
+}
+exports.EventTemplateCodec = EventTemplateCodec;

package/dist/xiot/core/spec/codec/template/PropertyTemplateCodec.d.ts

@@ -0,0 +1,7 @@
+import { PropertyTemplate } from '../../typedef/template/PropertyTemplate';
+export declare class PropertyTemplateCodec {
+    static decodeArray(array: any[]): PropertyTemplate[];
+    static decode(o: any): PropertyTemplate;
+    static encode(property: PropertyTemplate): Object;
+    static encodeArray(properties: Map<number, PropertyTemplate>): Array<Object>;
+}

package/dist/xiot/core/spec/codec/template/PropertyTemplateCodec.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTemplateCodec = void 0;
+const PropertyTemplate_1 = require("../../typedef/template/PropertyTemplate");
+const Spec_1 = require("../../typedef/constant/Spec");
+const PropertyCodec_1 = require("../instance/PropertyCodec");
+const PropertyType_1 = require("../../typedef/definition/urn/PropertyType");
+const DescriptionCodec_1 = require("../definition/DescriptionCodec");
+const DataFormat_1 = require("../../typedef/definition/property/data/DataFormat");
+const Access_1 = require("../../typedef/definition/property/Access");
+const PropertyDefinitionCodec_1 = require("../definition/PropertyDefinitionCodec");
+const ValueListCodec_1 = require("../definition/ValueListCodec");
+const ValueRangeCodec_1 = require("../definition/ValueRangeCodec");
+class PropertyTemplateCodec {
+    static decodeArray(array) {
+        const list = [];
+        if (array != null) {
+            for (const o of array) {
+                list.push(PropertyTemplateCodec.decode(o));
+            }
+        }
+        return list;
+    }
+    static decode(o) {
+        const iid = o[Spec_1.Spec.IID];
+        const type = new PropertyType_1.PropertyType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const format = (0, DataFormat_1.DataFormatFromString)(o[Spec_1.Spec.FORMAT]);
+        const access = Access_1.Access.create(o[Spec_1.Spec.ACCESS]);
+        let unit = null;
+        let constraintValue = null;
+        let members = [];
+        const required = o[Spec_1.Spec.X_REQUIRED];
+        const source = o[Spec_1.Spec.X_SOURCE];
+        if (format === DataFormat_1.DataFormat.COMBINATION) {
+            const members = PropertyDefinitionCodec_1.PropertyDefinitionCodec.decodeMembers(o[Spec_1.Spec.MEMBERS]);
+        }
+        else {
+            if (o.hasOwnProperty(Spec_1.Spec.VALUE_LIST) && o.hasOwnProperty(Spec_1.Spec.VALUE_RANGE)) {
+                throw new Error('value-list & value-range both exist!');
+            }
+            if (o.hasOwnProperty(Spec_1.Spec.VALUE_LIST)) {
+                constraintValue = ValueListCodec_1.ValueListCodec.decode(format, o[Spec_1.Spec.VALUE_LIST]);
+            }
+            if (o.hasOwnProperty(Spec_1.Spec.VALUE_RANGE)) {
+                constraintValue = ValueRangeCodec_1.ValueRangeCodec.decode(format, o[Spec_1.Spec.VALUE_RANGE]);
+            }
+        }
+        if (o.hasOwnProperty(Spec_1.Spec.UNIT)) {
+            unit = o[Spec_1.Spec.UNIT];
+        }
+        if (o.hasOwnProperty(Spec_1.Spec.MEMBERS)) {
+            members = o[Spec_1.Spec.MEMBERS];
+        }
+        const property = new PropertyTemplate_1.PropertyTemplate(iid, type, description, format, access, constraintValue, unit, members, required, source);
+        if (o[Spec_1.Spec.DEFAULT_VALUE] != null) {
+            property.setDefaultValue(o[Spec_1.Spec.DEFAULT_VALUE]);
+        }
+        return property;
+    }
+    static encode(property) {
+        const o = PropertyCodec_1.PropertyCodec.encode(property);
+        o[Spec_1.Spec.IID] = property.iid;
+        o[Spec_1.Spec.X_REQUIRED] = property.required;
+        if (property.source) {
+            o[Spec_1.Spec.X_SOURCE] = property.source;
+        }
+        return o;
+    }
+    static encodeArray(properties) {
+        const array = [];
+        properties.forEach(property => {
+            array.push(PropertyTemplateCodec.encode(property));
+        });
+        return array;
+    }
+}
+exports.PropertyTemplateCodec = PropertyTemplateCodec;

package/dist/xiot/core/spec/codec/template/ServiceTemplateCodec.d.ts

@@ -0,0 +1,7 @@
+import { ServiceTemplate } from '../../typedef/template/ServiceTemplate';
+export declare class ServiceTemplateCodec {
+    static decodeArray(array: any[]): ServiceTemplate[];
+    static decode(o: any): ServiceTemplate;
+    static encode(service: ServiceTemplate): any;
+    static encodeArray(services: Map<number, ServiceTemplate>): any[];
+}

package/dist/xiot/core/spec/codec/template/ServiceTemplateCodec.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceTemplateCodec = void 0;
+const ServiceTemplate_1 = require("../../typedef/template/ServiceTemplate");
+const Spec_1 = require("../../typedef/constant/Spec");
+const ServiceType_1 = require("../../typedef/definition/urn/ServiceType");
+const DescriptionCodec_1 = require("../definition/DescriptionCodec");
+const PropertyTemplateCodec_1 = require("./PropertyTemplateCodec");
+const ActionTemplateCodec_1 = require("./ActionTemplateCodec");
+const EventTemplateCodec_1 = require("./EventTemplateCodec");
+class ServiceTemplateCodec {
+    static decodeArray(array) {
+        const list = [];
+        if (array != null) {
+            for (const o of array) {
+                list.push(ServiceTemplateCodec.decode(o));
+            }
+        }
+        return list;
+    }
+    static decode(o) {
+        const iid = o[Spec_1.Spec.IID];
+        const required = o[Spec_1.Spec.X_REQUIRED];
+        const propertyAddable = o[Spec_1.Spec.X_PROPERTY_ADDABLE];
+        const actionAddable = o[Spec_1.Spec.X_ACTION_ADDABLE];
+        const eventAddable = o[Spec_1.Spec.X_ACTION_ADDABLE];
+        const source = o[Spec_1.Spec.X_SOURCE];
+        const type = new ServiceType_1.ServiceType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const properties = PropertyTemplateCodec_1.PropertyTemplateCodec.decodeArray(o[Spec_1.Spec.PROPERTIES]);
+        const actions = ActionTemplateCodec_1.ActionTemplateCodec.decodeArray(o[Spec_1.Spec.ACTIONS]);
+        const events = EventTemplateCodec_1.EventTemplateCodec.decodeArray(o[Spec_1.Spec.EVENTS]);
+        return new ServiceTemplate_1.ServiceTemplate(iid, required, type, description, properties, actions, events, propertyAddable, actionAddable, eventAddable, source);
+    }
+    static encode(service) {
+        const o = {
+            iid: service.iid,
+            type: service.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(service.description)
+        };
+        if (service.properties.size > 0) {
+            o[Spec_1.Spec.PROPERTIES] = PropertyTemplateCodec_1.PropertyTemplateCodec.encodeArray(service.properties);
+        }
+        if (service.actions.size > 0) {
+            o[Spec_1.Spec.ACTIONS] = ActionTemplateCodec_1.ActionTemplateCodec.encodeArray(service.actions);
+        }
+        if (service.events.size > 0) {
+            o[Spec_1.Spec.EVENTS] = EventTemplateCodec_1.EventTemplateCodec.encodeArray(service.events);
+        }
+        o[Spec_1.Spec.X_REQUIRED] = service.required;
+        o[Spec_1.Spec.X_PROPERTY_ADDABLE] = service.propertyAddable;
+        o[Spec_1.Spec.X_ACTION_ADDABLE] = service.actionAddable;
+        o[Spec_1.Spec.X_EVENT_ADDABLE] = service.eventAddable;
+        if (service.source) {
+            o[Spec_1.Spec.X_SOURCE] = service.source;
+        }
+        return o;
+    }
+    static encodeArray(services) {
+        const array = [];
+        services.forEach(service => {
+            array.push(ServiceTemplateCodec.encode(service));
+        });
+        return array;
+    }
+}
+exports.ServiceTemplateCodec = ServiceTemplateCodec;

package/dist/xiot/core/spec/typedef/app/Application.d.ts

@@ -0,0 +1,11 @@
+import { EventReceiver } from './event/EventReceiver';
+import { Authorization } from './authorization/Authorization';
+export declare class Application {
+    appId: string;
+    name: string;
+    eventReceiver: EventReceiver;
+    authorization: Authorization;
+    organization: string;
+    createBy: string;
+    createAt: string;
+}

package/dist/xiot/core/spec/typedef/app/Application.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+class Application {
+    constructor() {
+        this.appId = '';
+        this.name = '';
+        this.organization = '';
+        this.createBy = '';
+        this.createAt = '';
+    }
+}
+exports.Application = Application;

package/dist/xiot/core/spec/typedef/app/authorization/Authorization.d.ts

@@ -0,0 +1,5 @@
+import { AuthorizationType } from './AuthorizationType';
+export declare class Authorization {
+    type: AuthorizationType;
+    constructor(type: AuthorizationType);
+}

package/dist/xiot/core/spec/typedef/app/authorization/Authorization.js

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

package/dist/xiot/core/spec/typedef/app/authorization/AuthorizationType.d.ts

@@ -0,0 +1,8 @@
+export declare enum AuthorizationType {
+    UNDEFINED = "undefined",
+    EVENTBUS = "eventbus",
+    HTTP = "http",
+    JWT = "jwt"
+}
+export declare function AuthorizationTypeToString(type: AuthorizationType): string;
+export declare function AuthorizationTypeFromString(type: string): AuthorizationType;

package/dist/xiot/core/spec/typedef/app/authorization/AuthorizationType.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationType = void 0;
+exports.AuthorizationTypeToString = AuthorizationTypeToString;
+exports.AuthorizationTypeFromString = AuthorizationTypeFromString;
+var AuthorizationType;
+(function (AuthorizationType) {
+    AuthorizationType["UNDEFINED"] = "undefined";
+    AuthorizationType["EVENTBUS"] = "eventbus";
+    AuthorizationType["HTTP"] = "http";
+    AuthorizationType["JWT"] = "jwt";
+})(AuthorizationType || (exports.AuthorizationType = AuthorizationType = {}));
+function AuthorizationTypeToString(type) {
+    return type.toString();
+}
+function AuthorizationTypeFromString(type) {
+    const keys = Object.keys(AuthorizationType);
+    for (const key of keys) {
+        const s = AuthorizationTypeToString(AuthorizationType[key]);
+        if (s === type) {
+            return AuthorizationType[key];
+        }
+    }
+    return AuthorizationType.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/app/authorization/impl/AuthorizationEventbusImpl.d.ts

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