@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/codec/app/event/impl/EventReceiverHttpImplCodec.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiverHttpImplCodec = void 0;
+const EventReceiverHttpImpl_1 = require("../../../../typedef/app/event/impl/EventReceiverHttpImpl");
+class EventReceiverHttpImplCodec {
+    static encode(x) {
+        return {
+            url: x.url
+        };
+    }
+    static decode(o) {
+        return new EventReceiverHttpImpl_1.EventReceiverHttpImpl(o['url']);
+    }
+}
+exports.EventReceiverHttpImplCodec = EventReceiverHttpImplCodec;

package/dist/xiot/core/spec/codec/app/event/impl/EventReceiverKafkaImplCodec.d.ts

@@ -0,0 +1,5 @@
+import { EventReceiverKafkaImpl } from '../../../../typedef/app/event/impl/EventReceiverKafkaImpl';
+export declare class EventReceiverKafkaImplCodec {
+    static encode(x: EventReceiverKafkaImpl): any;
+    static decode(o: any): EventReceiverKafkaImpl;
+}

package/dist/xiot/core/spec/codec/app/event/impl/EventReceiverKafkaImplCodec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiverKafkaImplCodec = void 0;
+const EventReceiverKafkaImpl_1 = require("../../../../typedef/app/event/impl/EventReceiverKafkaImpl");
+class EventReceiverKafkaImplCodec {
+    static encode(x) {
+        return {
+            topic: x.topic,
+            bootstrapServers: x.bootstrapServers,
+        };
+    }
+    static decode(o) {
+        const topic = o.topic;
+        const bootstrapServers = o.bootstrapServers;
+        return new EventReceiverKafkaImpl_1.EventReceiverKafkaImpl(topic, bootstrapServers);
+    }
+}
+exports.EventReceiverKafkaImplCodec = EventReceiverKafkaImplCodec;

package/dist/xiot/core/spec/codec/definition/ActionDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { ActionDefinition } from '../../typedef/definition/ActionDefinition';
+export declare class ActionDefinitionCodec {
+    static decodeArray(list: any[]): ActionDefinition[];
+    static decode(o: any): ActionDefinition;
+    static encode(def: ActionDefinition): any;
+    static encodeArray(list: ActionDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/ActionDefinitionCodec.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionDefinitionCodec = void 0;
+const ActionDefinition_1 = require("../../typedef/definition/ActionDefinition");
+const ActionType_1 = require("../../typedef/definition/urn/ActionType");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+const Spec_1 = require("../../typedef/constant/Spec");
+const ArgumentDefinitionCodec_1 = require("./ArgumentDefinitionCodec");
+class ActionDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(o => {
+            array.push(ActionDefinitionCodec.decode(o));
+        });
+        return array;
+    }
+    static decode(o) {
+        const type = new ActionType_1.ActionType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const argumentsIn = ArgumentDefinitionCodec_1.ArgumentDefinitionCodec.decodeArray(o[Spec_1.Spec.IN]);
+        const argumentsOut = ArgumentDefinitionCodec_1.ArgumentDefinitionCodec.decodeArray(o[Spec_1.Spec.OUT]);
+        return new ActionDefinition_1.ActionDefinition(type, description, argumentsIn, argumentsOut);
+    }
+    static encode(def) {
+        const o = {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+        if (def.in.length > 0) {
+            o[Spec_1.Spec.IN] = ArgumentDefinitionCodec_1.ArgumentDefinitionCodec.encodeArray(def.in);
+        }
+        if (def.out.length > 0) {
+            o[Spec_1.Spec.OUT] = ArgumentDefinitionCodec_1.ArgumentDefinitionCodec.encodeArray(def.out);
+        }
+        return o;
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return ActionDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.ActionDefinitionCodec = ActionDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/ArgumentDefinitionCodec.d.ts

@@ -0,0 +1,8 @@
+import { ArgumentDefinition } from '../../typedef/definition/ArgumentDefinition';
+export declare class ArgumentDefinitionCodec {
+    static decodeArray(list: any[]): ArgumentDefinition[];
+    static decodeString(s: string): ArgumentDefinition;
+    static decodeObject(o: any): ArgumentDefinition;
+    static encode(def: ArgumentDefinition): any;
+    static encodeArray(list: ArgumentDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/ArgumentDefinitionCodec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentDefinitionCodec = void 0;
+const ArgumentDefinition_1 = require("../../typedef/definition/ArgumentDefinition");
+const PropertyType_1 = require("../../typedef/definition/urn/PropertyType");
+const Spec_1 = require("../../typedef/constant/Spec");
+class ArgumentDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                if (typeof o === 'string') {
+                    array.push(ArgumentDefinitionCodec.decodeString(o));
+                    continue;
+                }
+                if (typeof o === 'object') {
+                    array.push(ArgumentDefinitionCodec.decodeObject(o));
+                }
+            }
+        }
+        return array;
+    }
+    static decodeString(s) {
+        return new ArgumentDefinition_1.ArgumentDefinition(new PropertyType_1.PropertyType(s));
+    }
+    static decodeObject(o) {
+        const type = new PropertyType_1.PropertyType(o[Spec_1.Spec.PROPERTY]);
+        const def = new ArgumentDefinition_1.ArgumentDefinition(type);
+        const repeat = o[Spec_1.Spec.REPEAT];
+        if (repeat != null) {
+            def.minRepeat = repeat[0];
+            def.maxRepeat = repeat[1];
+        }
+        return def;
+    }
+    static encode(def) {
+        return {
+            property: def.type.toString(),
+            repeat: [def.minRepeat, def.maxRepeat]
+        };
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return ArgumentDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.ArgumentDefinitionCodec = ArgumentDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/CategoryDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { CategoryDefinition } from '../../typedef/definition/CategoryDefinition';
+export declare class CategoryDefinitionCodec {
+    static decodeArray(list: any[]): CategoryDefinition[];
+    static decode(o: any): CategoryDefinition;
+    static encode(def: CategoryDefinition): any;
+    static encodeArray(list: CategoryDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/CategoryDefinitionCodec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryDefinitionCodec = void 0;
+const DescriptionCodec_1 = require("./DescriptionCodec");
+const CategoryDefinition_1 = require("../../typedef/definition/CategoryDefinition");
+const Spec_1 = require("../../typedef/constant/Spec");
+class CategoryDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(o => {
+            array.push(CategoryDefinitionCodec.decode(o));
+        });
+        return array;
+    }
+    static decode(o) {
+        const name = o[Spec_1.Spec.NAME];
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        return new CategoryDefinition_1.CategoryDefinition(name, description);
+    }
+    static encode(def) {
+        return {
+            name: def.name,
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return CategoryDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.CategoryDefinitionCodec = CategoryDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/DescriptionCodec.d.ts

@@ -0,0 +1,4 @@
+export declare class DescriptionCodec {
+    static decode(o: any): Map<string, string>;
+    static encode(description: Map<string, string>): any;
+}

package/dist/xiot/core/spec/codec/definition/DescriptionCodec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptionCodec = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+class DescriptionCodec {
+    static decode(o) {
+        const description = new Map();
+        if (typeof o === 'string') {
+            description.set(Spec_1.Spec.EN_US, o);
+        }
+        else if (typeof o === 'object') {
+            Object.keys(o).forEach(x => {
+                description.set(x.toString(), o[x]);
+            });
+        }
+        return description;
+    }
+    static encode(description) {
+        if (description.size === 0) {
+            return '';
+        }
+        if (description.size === 1) {
+            return description.get(Spec_1.Spec.EN_US);
+        }
+        const o = Object.create(null);
+        description.forEach((value, key) => {
+            o[key.toString()] = value;
+        });
+        return o;
+    }
+}
+exports.DescriptionCodec = DescriptionCodec;

package/dist/xiot/core/spec/codec/definition/DeviceDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { DeviceDefinition } from '../../typedef/definition/DeviceDefinition';
+export declare class DeviceDefinitionCodec {
+    static decodeArray(list: any[]): DeviceDefinition[];
+    static decode(o: any): DeviceDefinition;
+    static encode(def: DeviceDefinition): any;
+    static encodeArray(list: DeviceDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/DeviceDefinitionCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceDefinitionCodec = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const DeviceDefinition_1 = require("../../typedef/definition/DeviceDefinition");
+const DeviceType_1 = require("../../typedef/definition/urn/DeviceType");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+class DeviceDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(o => {
+            array.push(DeviceDefinitionCodec.decode(o));
+        });
+        return array;
+    }
+    static decode(o) {
+        const category = o.category;
+        const type = new DeviceType_1.DeviceType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        return new DeviceDefinition_1.DeviceDefinition(category, type, description);
+    }
+    static encode(def) {
+        const o = {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+        if (def.category != null) {
+            o.category = def.category;
+        }
+        return o;
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return DeviceDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.DeviceDefinitionCodec = DeviceDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/EventDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { EventDefinition } from '../../typedef/definition/EventDefinition';
+export declare class EventDefinitionCodec {
+    static decodeArray(list: any[]): EventDefinition[];
+    static decode(o: any): EventDefinition;
+    static encode(def: EventDefinition): any;
+    static encodeArray(list: EventDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/EventDefinitionCodec.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDefinitionCodec = void 0;
+const EventDefinition_1 = require("../../typedef/definition/EventDefinition");
+const EventType_1 = require("../../typedef/definition/urn/EventType");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+const ArgumentDefinitionCodec_1 = require("./ArgumentDefinitionCodec");
+const Spec_1 = require("../../typedef/constant/Spec");
+class EventDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(o => {
+            array.push(EventDefinitionCodec.decode(o));
+        });
+        return array;
+    }
+    static decode(o) {
+        const type = new EventType_1.EventType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const list = ArgumentDefinitionCodec_1.ArgumentDefinitionCodec.decodeArray(o[Spec_1.Spec.ARGUMENTS]);
+        return new EventDefinition_1.EventDefinition(type, description, list);
+    }
+    static encode(def) {
+        const o = {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+        if (def.arguments.length > 0) {
+            o[Spec_1.Spec.ARGUMENTS] = ArgumentDefinitionCodec_1.ArgumentDefinitionCodec.encodeArray(def.arguments);
+        }
+        return o;
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return EventDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.EventDefinitionCodec = EventDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/FormatDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { FormatDefinition } from '../../typedef/definition/FormatDefinition';
+export declare class FormatDefinitionCodec {
+    static decodeArray(list: any[]): FormatDefinition[];
+    static decode(o: any): FormatDefinition;
+    static encode(def: FormatDefinition): any;
+    static encodeArray(list: FormatDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/FormatDefinitionCodec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatDefinitionCodec = void 0;
+const FormatDefinition_1 = require("../../typedef/definition/FormatDefinition");
+const FormatType_1 = require("../../typedef/definition/urn/FormatType");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+const Spec_1 = require("../../typedef/constant/Spec");
+class FormatDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                array.push(FormatDefinitionCodec.decode(o));
+            }
+        }
+        return array;
+    }
+    static decode(o) {
+        const type = FormatType_1.FormatType.parse(o[Spec_1.Spec.TYPE] || '');
+        return new FormatDefinition_1.FormatDefinition(type, DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]));
+    }
+    static encode(def) {
+        return {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return FormatDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.FormatDefinitionCodec = FormatDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/NamespaceDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { NamespaceDefinition } from '../../typedef/definition/NamespaceDefinition';
+export declare class NamespaceDefinitionCodec {
+    static decodeArray(list: any[]): NamespaceDefinition[];
+    static decode(o: any): NamespaceDefinition;
+    static encode(def: NamespaceDefinition): any;
+    static encodeArray(list: NamespaceDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/NamespaceDefinitionCodec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceDefinitionCodec = void 0;
+const NamespaceDefinition_1 = require("../../typedef/definition/NamespaceDefinition");
+const Spec_1 = require("../../typedef/constant/Spec");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+class NamespaceDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(o => {
+            array.push(NamespaceDefinitionCodec.decode(o));
+        });
+        return array;
+    }
+    static decode(o) {
+        const namespace = o[Spec_1.Spec.NAMESPACE];
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        return new NamespaceDefinition_1.NamespaceDefinition(namespace, description);
+    }
+    static encode(def) {
+        return {
+            namespace: def.namespace,
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return NamespaceDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.NamespaceDefinitionCodec = NamespaceDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/PropertyDefinitionCodec.d.ts

@@ -0,0 +1,9 @@
+import { PropertyType } from '../../typedef/definition/urn/PropertyType';
+import { PropertyDefinition } from '../../typedef/definition/PropertyDefinition';
+export declare class PropertyDefinitionCodec {
+    static decodeMembers(array: any[]): PropertyType[];
+    static decodeArray(list: any[]): PropertyDefinition[];
+    static decode(o: any): PropertyDefinition;
+    static encode(def: PropertyDefinition): any;
+    static encodeArray(list: PropertyDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/PropertyDefinitionCodec.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyDefinitionCodec = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const PropertyType_1 = require("../../typedef/definition/urn/PropertyType");
+const PropertyDefinition_1 = require("../../typedef/definition/PropertyDefinition");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+const DataFormat_1 = require("../../typedef/definition/property/data/DataFormat");
+const Access_1 = require("../../typedef/definition/property/Access");
+const ValueListCodec_1 = require("./ValueListCodec");
+const ValueRangeCodec_1 = require("./ValueRangeCodec");
+const ValueList_1 = require("../../typedef/definition/property/ValueList");
+const ValueRange_1 = require("../../typedef/definition/property/ValueRange");
+const PropertyTypeCodec_1 = require("./type/PropertyTypeCodec");
+class PropertyDefinitionCodec {
+    static decodeMembers(array) {
+        const list = [];
+        if (array === null || array === void 0 ? void 0 : array.length) {
+            for (const o of array) {
+                // if (typeof o === 'number') {
+                //   list.push(o);
+                // }
+                if (typeof o === 'string') {
+                    list.push(new PropertyType_1.PropertyType(o));
+                }
+            }
+        }
+        return list;
+    }
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(json => {
+            array.push(PropertyDefinitionCodec.decode(json));
+        });
+        return array;
+    }
+    static decode(o) {
+        const type = new PropertyType_1.PropertyType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const def = new PropertyDefinition_1.PropertyDefinition(type, description);
+        def.format = (0, DataFormat_1.DataFormatFromString)(o[Spec_1.Spec.FORMAT]);
+        def.access = Access_1.Access.create(o[Spec_1.Spec.ACCESS]);
+        def.unit = o[Spec_1.Spec.UNIT];
+        if (def.format === DataFormat_1.DataFormat.COMBINATION) {
+            def.members = 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)) {
+                def.constraintValue = ValueListCodec_1.ValueListCodec.decode(def.format, o[Spec_1.Spec.VALUE_LIST]);
+            }
+            if (o.hasOwnProperty(Spec_1.Spec.VALUE_RANGE)) {
+                def.constraintValue = ValueRangeCodec_1.ValueRangeCodec.decode(def.format, o[Spec_1.Spec.VALUE_RANGE]);
+            }
+        }
+        return def;
+    }
+    static encode(def) {
+        var _a;
+        const o = {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description),
+            format: (0, DataFormat_1.DataFormatToString)(def.format),
+            access: def.access.toList()
+        };
+        if (def.constraintValue != null) {
+            if (def.constraintValue instanceof ValueList_1.ValueList) {
+                o[Spec_1.Spec.VALUE_LIST] = ValueListCodec_1.ValueListCodec.encode(def.constraintValue);
+            }
+            if (def.constraintValue instanceof ValueRange_1.ValueRange) {
+                o[Spec_1.Spec.VALUE_RANGE] = ValueRangeCodec_1.ValueRangeCodec.encode(def.constraintValue);
+            }
+        }
+        if (def.unit != null) {
+            o[Spec_1.Spec.UNIT] = def.unit;
+        }
+        if (((_a = def.members) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            if (def.members[0] instanceof PropertyType_1.PropertyType) {
+                o[Spec_1.Spec.MEMBERS] = PropertyTypeCodec_1.PropertyTypeCodec.encodeArray(def.members);
+            }
+            else {
+                o[Spec_1.Spec.MEMBERS] = def.members;
+            }
+        }
+        return o;
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return PropertyDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.PropertyDefinitionCodec = PropertyDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/ServiceDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { ServiceDefinition } from '../../typedef/definition/ServiceDefinition';
+export declare class ServiceDefinitionCodec {
+    static decodeArray(list: any[]): ServiceDefinition[];
+    static decode(o: any): ServiceDefinition;
+    static encode(def: ServiceDefinition): any;
+    static encodeArray(list: ServiceDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/ServiceDefinitionCodec.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDefinitionCodec = void 0;
+const ServiceDefinition_1 = require("../../typedef/definition/ServiceDefinition");
+const ServiceType_1 = require("../../typedef/definition/urn/ServiceType");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+const PropertyTypeCodec_1 = require("./type/PropertyTypeCodec");
+const ActionTypeCodec_1 = require("./type/ActionTypeCodec");
+const EventTypeCodec_1 = require("./type/EventTypeCodec");
+const Spec_1 = require("../../typedef/constant/Spec");
+class ServiceDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        list.forEach(o => {
+            array.push(ServiceDefinitionCodec.decode(o));
+        });
+        return array;
+    }
+    static decode(o) {
+        const type = new ServiceType_1.ServiceType(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const requiredProperties = PropertyTypeCodec_1.PropertyTypeCodec.decodeArray(o[Spec_1.Spec.REQUIRED_PROPERTIES]);
+        const optionalProperties = PropertyTypeCodec_1.PropertyTypeCodec.decodeArray(o[Spec_1.Spec.OPTIONAL_PROPERTIES]);
+        const requiredActions = ActionTypeCodec_1.ActionTypeCodec.decodeArray(o[Spec_1.Spec.REQUIRED_ACTIONS]);
+        const optionalActions = ActionTypeCodec_1.ActionTypeCodec.decodeArray(o[Spec_1.Spec.OPTIONAL_ACTIONS]);
+        const requiredEvents = EventTypeCodec_1.EventTypeCodec.decodeArray(o[Spec_1.Spec.REQUIRED_EVENTS]);
+        const optionalEvents = EventTypeCodec_1.EventTypeCodec.decodeArray(o[Spec_1.Spec.OPTIONAL_EVENTS]);
+        if (type.ns === 'homekit-spec') {
+            type._property_addable = true;
+            type._action_addable = false;
+            type._event_addable = false;
+        }
+        else {
+            type._property_addable = true;
+            type._action_addable = true;
+            type._event_addable = true;
+        }
+        return new ServiceDefinition_1.ServiceDefinition(type, description, requiredProperties, optionalProperties, requiredActions, optionalActions, requiredEvents, optionalEvents);
+    }
+    static encode(def) {
+        const o = {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+        if (def.requiredProperties.length > 0) {
+            o[Spec_1.Spec.REQUIRED_PROPERTIES] = PropertyTypeCodec_1.PropertyTypeCodec.encodeArray(def.requiredProperties);
+        }
+        if (def.optionalProperties.length > 0) {
+            o[Spec_1.Spec.OPTIONAL_PROPERTIES] = PropertyTypeCodec_1.PropertyTypeCodec.encodeArray(def.optionalProperties);
+        }
+        if (def.requiredActions.length > 0) {
+            o[Spec_1.Spec.REQUIRED_ACTIONS] = ActionTypeCodec_1.ActionTypeCodec.encodeArray(def.requiredActions);
+        }
+        if (def.optionalActions.length > 0) {
+            o[Spec_1.Spec.OPTIONAL_ACTIONS] = ActionTypeCodec_1.ActionTypeCodec.encodeArray(def.optionalActions);
+        }
+        if (def.requiredEvents.length > 0) {
+            o[Spec_1.Spec.REQUIRED_EVENTS] = EventTypeCodec_1.EventTypeCodec.encodeArray(def.requiredEvents);
+        }
+        if (def.optionalEvents.length > 0) {
+            o[Spec_1.Spec.OPTIONAL_EVENTS] = EventTypeCodec_1.EventTypeCodec.encodeArray(def.optionalEvents);
+        }
+        return o;
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return ServiceDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.ServiceDefinitionCodec = ServiceDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/UnitDefinitionCodec.d.ts

@@ -0,0 +1,7 @@
+import { UnitDefinition } from '../../typedef/definition/UnitDefinition';
+export declare class UnitDefinitionCodec {
+    static decodeArray(list: any[]): UnitDefinition[];
+    static decode(o: any): UnitDefinition;
+    static encode(def: UnitDefinition): any;
+    static encodeArray(list: UnitDefinition[]): any[];
+}

package/dist/xiot/core/spec/codec/definition/UnitDefinitionCodec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitDefinitionCodec = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const UnitDefinition_1 = require("../../typedef/definition/UnitDefinition");
+const UnitType_1 = require("../../typedef/definition/urn/UnitType");
+const DescriptionCodec_1 = require("./DescriptionCodec");
+class UnitDefinitionCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            for (const o of list) {
+                array.push(UnitDefinitionCodec.decode(o));
+            }
+        }
+        return array;
+    }
+    static decode(o) {
+        const type = UnitType_1.UnitType.parse(o[Spec_1.Spec.TYPE] || '');
+        return new UnitDefinition_1.UnitDefinition(type, DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]));
+    }
+    static encode(def) {
+        return {
+            type: def.type.toString(),
+            description: DescriptionCodec_1.DescriptionCodec.encode(def.description)
+        };
+    }
+    static encodeArray(list) {
+        return list.map(x => {
+            return UnitDefinitionCodec.encode(x);
+        });
+    }
+}
+exports.UnitDefinitionCodec = UnitDefinitionCodec;

package/dist/xiot/core/spec/codec/definition/ValueListCodec.d.ts

@@ -0,0 +1,6 @@
+import { ValueList } from '../../typedef/definition/property/ValueList';
+import { DataFormat } from '../../typedef/definition/property/data/DataFormat';
+export declare class ValueListCodec {
+    static decode(format: DataFormat, array: any[]): ValueList;
+    static encode(list: ValueList): any[];
+}