@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/codec/operation/ArgumentOperationCodec.d.ts

@@ -0,0 +1,10 @@
+import { ArgumentOperation } from '../../typedef/operation/ArgumentOperation';
+export declare class ArgumentOperationCodec {
+    static decodeArray(list: any[]): ArgumentOperation[];
+    static decodeObjet(o: any): ArgumentOperation[];
+    private static decodeArgument1;
+    private static decodeArgument2;
+    static decode(o: any): ArgumentOperation;
+    static encode(argument: ArgumentOperation): any;
+    static encodeArray(compact: boolean, list: ArgumentOperation[]): any[];
+}

package/dist/xiot/core/spec/codec/operation/ArgumentOperationCodec.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentOperationCodec = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const ArgumentOperation_1 = require("../../typedef/operation/ArgumentOperation");
+class ArgumentOperationCodec {
+    static decodeArray(list) {
+        const array = [];
+        if (list != null) {
+            list.forEach(o => {
+                const a = ArgumentOperationCodec.decode(o);
+                if (a != null) {
+                    array.push(a);
+                }
+            });
+        }
+        return array;
+    }
+    static decodeObjet(o) {
+        const list = [];
+        Object.keys(o).forEach(key => {
+            if (key.startsWith('#')) {
+                const iid = key.substring(1);
+                const k = o[key];
+                if (k instanceof Array) {
+                    list.push(ArgumentOperationCodec.decodeArgument1(iid, k));
+                }
+            }
+        });
+        return list;
+    }
+    static decodeArgument1(piid, values) {
+        return ArgumentOperationCodec.decodeArgument2(Number.parseInt(piid), values);
+    }
+    static decodeArgument2(piid, values) {
+        return new ArgumentOperation_1.ArgumentOperation(piid, values);
+    }
+    static decode(o) {
+        if (typeof o === 'number') {
+            return new ArgumentOperation_1.ArgumentOperation(o, []);
+        }
+        return new ArgumentOperation_1.ArgumentOperation(o[Spec_1.Spec.PIID] || 0, o[Spec_1.Spec.VALUES] || []);
+    }
+    static encode(argument) {
+        return {
+            piid: argument.piid,
+            values: argument.values
+        };
+    }
+    static encodeArray(compact, list) {
+        if (compact) {
+            const object = {};
+            for (let i = 0; i < list.length; i++) {
+                object['#' + list[i].piid] = list[i].values;
+            }
+            return object;
+        }
+        else {
+            return list.map(x => {
+                return ArgumentOperationCodec.encode(x);
+            });
+        }
+    }
+}
+exports.ArgumentOperationCodec = ArgumentOperationCodec;

package/dist/xiot/core/spec/codec/operation/CombinationValueCodec.d.ts

@@ -0,0 +1,6 @@
+export declare class CombinationValueCodec {
+    static decodeObject(o: any): Map<number, any>;
+    static decodeArray(array: any[]): Map<number, any>;
+    static encodeWithCompact(compact: boolean, members: Map<any, any>): any;
+    static encode(members: Map<number, any>): any;
+}

package/dist/xiot/core/spec/codec/operation/CombinationValueCodec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CombinationValueCodec = void 0;
+class CombinationValueCodec {
+    static decodeObject(o) {
+        const members = new Map();
+        // tslint:disable-next-line:forin
+        for (const key in o) {
+            const piid = key.substring(1);
+            members.set(parseInt(piid, 10), o[key]);
+        }
+        return members;
+    }
+    static decodeArray(array) {
+        const members = new Map();
+        if (array === null || array === void 0 ? void 0 : array.length) {
+            array.forEach(o => {
+                if (typeof o === 'object') {
+                    const piid = o.piid;
+                    const value = o.value;
+                    // value = [{}, {}, {}]，这里被识别为object
+                    if (typeof value === 'object') {
+                        members.set(piid, CombinationValueCodec.decodeArray(value));
+                    }
+                    else {
+                        members.set(piid, value);
+                    }
+                }
+            });
+        }
+        return members;
+    }
+    static encodeWithCompact(compact, members) {
+        const keys = Array.from(members.keys());
+        if (compact) {
+            const o = {};
+            for (const key of keys) {
+                const value = members.get(key);
+                if (typeof value === 'object') {
+                    o[`#${key}`] = CombinationValueCodec.encodeWithCompact(compact, value);
+                }
+                else {
+                    o[`#${key}`] = value;
+                }
+            }
+            return o;
+        }
+        const array = [];
+        for (const key of keys) {
+            const value = members.get(key);
+            if (typeof value === 'object') {
+                array.push({
+                    piid: key,
+                    value: CombinationValueCodec.encodeWithCompact(compact, value)
+                });
+            }
+            else {
+                array.push({
+                    piid: key,
+                    value: value
+                });
+            }
+        }
+        return array;
+    }
+    static encode(members) {
+        return this.encodeWithCompact(false, members);
+    }
+}
+exports.CombinationValueCodec = CombinationValueCodec;

package/dist/xiot/core/spec/codec/operation/EventOperationCodec.d.ts

@@ -0,0 +1,14 @@
+import { AbstractOperationCodec } from './AbstractOperationCodec';
+import { EventOperation } from '../../typedef/operation/EventOperation';
+export declare class EventOperationCodecQuery extends AbstractOperationCodec<EventOperation, any> {
+    decodeObject(o: any): EventOperation;
+    encodeObject(event: EventOperation): any;
+}
+export declare class EventOperationCodecResult extends AbstractOperationCodec<EventOperation, any> {
+    decodeObject(o: any): EventOperation;
+    encodeObject(event: EventOperation): any;
+}
+export declare class EventOperationCodec {
+    static Query: EventOperationCodecQuery;
+    static Result: EventOperationCodecResult;
+}

package/dist/xiot/core/spec/codec/operation/EventOperationCodec.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventOperationCodec = exports.EventOperationCodecResult = exports.EventOperationCodecQuery = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const AbstractOperationCodec_1 = require("./AbstractOperationCodec");
+const EventOperation_1 = require("../../typedef/operation/EventOperation");
+const EventID_1 = require("../../typedef/xid/EventID");
+const ArgumentOperationCodec_1 = require("./ArgumentOperationCodec");
+class EventOperationCodecQuery extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        const event = new EventOperation_1.EventOperation();
+        event.eid = EventID_1.EventID.parse(o[Spec_1.Spec.EID]);
+        event.oid = o[Spec_1.Spec.OID] || '';
+        if (o[Spec_1.Spec.ARGUMENTS] != null) {
+            if (o[Spec_1.Spec.ARGUMENTS] instanceof Array) {
+                event.setArguments(ArgumentOperationCodec_1.ArgumentOperationCodec.decodeArray(o[Spec_1.Spec.ARGUMENTS]));
+            }
+            else {
+                event.argumentsCompact = true;
+                event.setArguments(ArgumentOperationCodec_1.ArgumentOperationCodec.decodeObjet(o[Spec_1.Spec.ARGUMENTS]));
+            }
+        }
+        return event;
+    }
+    encodeObject(event) {
+        const object = {
+            eid: event.eid.toString(),
+            oid: event.oid
+        };
+        if (event.getArguments().length > 0) {
+            object[Spec_1.Spec.ARGUMENTS] = ArgumentOperationCodec_1.ArgumentOperationCodec.encodeArray(event.argumentsCompact, event.getArguments());
+        }
+        return object;
+    }
+}
+exports.EventOperationCodecQuery = EventOperationCodecQuery;
+class EventOperationCodecResult extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        const event = new EventOperation_1.EventOperation();
+        event.eid = EventID_1.EventID.parse(o[Spec_1.Spec.EID]);
+        event.status = o[Spec_1.Spec.STATUS];
+        if (event.status !== 0) {
+            event.description = o[Spec_1.Spec.DESCRIPTION];
+        }
+        return event;
+    }
+    encodeObject(event) {
+        const object = {
+            eid: event.eid.toString(),
+            status: event.status
+        };
+        if (event.status !== 0) {
+            object.description = event.description;
+        }
+        return object;
+    }
+}
+exports.EventOperationCodecResult = EventOperationCodecResult;
+class EventOperationCodec {
+}
+exports.EventOperationCodec = EventOperationCodec;
+EventOperationCodec.Query = new EventOperationCodecQuery();
+EventOperationCodec.Result = new EventOperationCodecResult();

package/dist/xiot/core/spec/codec/operation/PropertyOperationCodec.d.ts

@@ -0,0 +1,31 @@
+import { AbstractOperationCodec } from './AbstractOperationCodec';
+import { PropertyOperation } from '../../typedef/operation/PropertyOperation';
+export declare class PropertyOperationCodecGetQuery extends AbstractOperationCodec<PropertyOperation, string> {
+    decodeObject(o: any): PropertyOperation;
+    encodeObject(t: PropertyOperation): string;
+}
+export declare class PropertyOperationCodecGetResult extends AbstractOperationCodec<PropertyOperation, any> {
+    decodeObject(o: any): PropertyOperation;
+    encodeObject(property: PropertyOperation): any;
+}
+export declare class PropertyOperationCodecSetQuery extends AbstractOperationCodec<PropertyOperation, any> {
+    decodeObject(o: any): PropertyOperation;
+    encodeObject(property: PropertyOperation): any;
+}
+export declare class PropertyOperationCodecSetResult extends AbstractOperationCodec<PropertyOperation, any> {
+    decodeObject(o: any): PropertyOperation;
+    encodeObject(property: PropertyOperation): any;
+}
+export declare class PropertyOperationCodecGet {
+    QUERY: PropertyOperationCodecGetQuery;
+    RESULT: PropertyOperationCodecGetResult;
+}
+export declare class PropertyOperationCodecSet {
+    QUERY: PropertyOperationCodecSetQuery;
+    RESULT: PropertyOperationCodecSetResult;
+}
+export declare class PropertyOperationCodec {
+    static Get: PropertyOperationCodecGet;
+    static Set: PropertyOperationCodecSet;
+    static Notify: PropertyOperationCodecSetQuery;
+}

package/dist/xiot/core/spec/codec/operation/PropertyOperationCodec.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyOperationCodec = exports.PropertyOperationCodecSet = exports.PropertyOperationCodecGet = exports.PropertyOperationCodecSetResult = exports.PropertyOperationCodecSetQuery = exports.PropertyOperationCodecGetResult = exports.PropertyOperationCodecGetQuery = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const AbstractOperationCodec_1 = require("./AbstractOperationCodec");
+const PropertyOperation_1 = require("../../typedef/operation/PropertyOperation");
+const PropertyID_1 = require("../../typedef/xid/PropertyID");
+const CombinationValueCodec_1 = require("./CombinationValueCodec");
+class PropertyOperationCodecGetQuery extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        if (typeof o === 'string') {
+            const property = new PropertyOperation_1.PropertyOperation();
+            property.pid = PropertyID_1.PropertyID.parse(o);
+            return property;
+        }
+        throw Error(`invalid pid: ${o}`);
+    }
+    encodeObject(t) {
+        return t.pid.toString();
+    }
+}
+exports.PropertyOperationCodecGetQuery = PropertyOperationCodecGetQuery;
+class PropertyOperationCodecGetResult extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        const property = new PropertyOperation_1.PropertyOperation();
+        property.pid = PropertyID_1.PropertyID.parse(o[Spec_1.Spec.PID]);
+        property.status = o[Spec_1.Spec.STATUS];
+        if (property.status === undefined) {
+            property.status = 0;
+        }
+        if (property.status == null) {
+            property.status = 0;
+        }
+        if (property.status === 0) {
+            const value = o[Spec_1.Spec.VALUE];
+            if (value instanceof Array) {
+                property.value = CombinationValueCodec_1.CombinationValueCodec.decodeArray(value);
+            }
+            else if (typeof value === 'object') {
+                property.argumentsCompact = true;
+                property.value = CombinationValueCodec_1.CombinationValueCodec.decodeObject(value);
+            }
+            else {
+                property.value = value;
+            }
+        }
+        else {
+            property.description = o[Spec_1.Spec.DESCRIPTION];
+        }
+        return property;
+    }
+    encodeObject(property) {
+        const o = {
+            pid: property.pid.toString()
+        };
+        if (property.status === 0) {
+            if (property.value instanceof Map) {
+                o[Spec_1.Spec.VALUE] = CombinationValueCodec_1.CombinationValueCodec.encodeWithCompact(property.argumentsCompact, property.value);
+            }
+            else {
+                o[Spec_1.Spec.VALUE] = property.value;
+            }
+        }
+        else {
+            o[Spec_1.Spec.STATUS] = property.status;
+            o[Spec_1.Spec.DESCRIPTION] = property.description;
+        }
+        return o;
+    }
+}
+exports.PropertyOperationCodecGetResult = PropertyOperationCodecGetResult;
+class PropertyOperationCodecSetQuery extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        const property = new PropertyOperation_1.PropertyOperation();
+        const value = o[Spec_1.Spec.VALUE];
+        property.pid = PropertyID_1.PropertyID.parse(o[Spec_1.Spec.PID]);
+        if (value !== null) {
+            if (value instanceof Array) {
+                property.value = CombinationValueCodec_1.CombinationValueCodec.decodeArray(value);
+            }
+            else if (typeof value === 'object') {
+                property.argumentsCompact = true;
+                property.value = CombinationValueCodec_1.CombinationValueCodec.decodeObject(value);
+            }
+            else {
+                property.value = value;
+            }
+        }
+        return property;
+    }
+    encodeObject(property) {
+        return {
+            pid: property.pid.toString(),
+            value: property.value instanceof Map
+                ? CombinationValueCodec_1.CombinationValueCodec.encodeWithCompact(property.argumentsCompact, property.value)
+                : property.value
+        };
+    }
+}
+exports.PropertyOperationCodecSetQuery = PropertyOperationCodecSetQuery;
+class PropertyOperationCodecSetResult extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        const property = new PropertyOperation_1.PropertyOperation();
+        property.pid = PropertyID_1.PropertyID.parse(o[Spec_1.Spec.PID]);
+        property.status = o[Spec_1.Spec.STATUS];
+        if (property.status === undefined) {
+            property.status = 0;
+        }
+        if (property.status == null) {
+            property.status = 0;
+        }
+        if (property.status !== 0) {
+            property.description = o[Spec_1.Spec.DESCRIPTION];
+        }
+        // if (property.description === undefined) {
+        //     throw new Error('description undefined');
+        // }
+        return property;
+    }
+    encodeObject(property) {
+        const o = {
+            pid: property.pid.toString(),
+            status: property.status
+        };
+        if (property.status !== 0) {
+            o[Spec_1.Spec.DESCRIPTION] = property.description;
+        }
+        return o;
+    }
+}
+exports.PropertyOperationCodecSetResult = PropertyOperationCodecSetResult;
+class PropertyOperationCodecGet {
+    constructor() {
+        this.QUERY = new PropertyOperationCodecGetQuery();
+        this.RESULT = new PropertyOperationCodecGetResult();
+    }
+}
+exports.PropertyOperationCodecGet = PropertyOperationCodecGet;
+class PropertyOperationCodecSet {
+    constructor() {
+        this.QUERY = new PropertyOperationCodecSetQuery();
+        this.RESULT = new PropertyOperationCodecSetResult();
+    }
+}
+exports.PropertyOperationCodecSet = PropertyOperationCodecSet;
+class PropertyOperationCodec {
+}
+exports.PropertyOperationCodec = PropertyOperationCodec;
+PropertyOperationCodec.Get = new PropertyOperationCodecGet();
+PropertyOperationCodec.Set = new PropertyOperationCodecSet();
+PropertyOperationCodec.Notify = new PropertyOperationCodecSetQuery();

package/dist/xiot/core/spec/codec/operation/RuleOperationCodec.d.ts

@@ -0,0 +1,14 @@
+import { AbstractOperationCodec } from './AbstractOperationCodec';
+import { RuleOperation } from '../../typedef/operation/RuleOperation';
+export declare class RuleOperationCodecQuery extends AbstractOperationCodec<RuleOperation, String> {
+    decodeObject(o: any): RuleOperation;
+    encodeObject(o: RuleOperation): any;
+}
+export declare class RuleOperationCodecResult extends AbstractOperationCodec<RuleOperation, any> {
+    decodeObject(o: any): RuleOperation;
+    encodeObject(operation: RuleOperation): any;
+}
+export declare class RuleOperationCodec {
+    static Query: RuleOperationCodecQuery;
+    static Result: RuleOperationCodecResult;
+}

package/dist/xiot/core/spec/codec/operation/RuleOperationCodec.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleOperationCodec = exports.RuleOperationCodecResult = exports.RuleOperationCodecQuery = void 0;
+const Spec_1 = require("../../typedef/constant/Spec");
+const AbstractOperationCodec_1 = require("./AbstractOperationCodec");
+const RuleOperation_1 = require("../../typedef/operation/RuleOperation");
+class RuleOperationCodecQuery extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        return new RuleOperation_1.RuleOperation(o);
+    }
+    encodeObject(o) {
+        if (o.status < 0) {
+            return null;
+        }
+        return o.ruleId;
+    }
+}
+exports.RuleOperationCodecQuery = RuleOperationCodecQuery;
+class RuleOperationCodecResult extends AbstractOperationCodec_1.AbstractOperationCodec {
+    decodeObject(o) {
+        const operation = new RuleOperation_1.RuleOperation(o.ruleId);
+        if (o.status < 0) {
+            operation.description = o[Spec_1.Spec.DESCRIPTION];
+        }
+        return operation;
+    }
+    encodeObject(operation) {
+        const object = {
+            ruleId: operation.ruleId,
+            status: operation.status
+        };
+        if (operation.status < 0) {
+            object[Spec_1.Spec.DESCRIPTION] = operation.description;
+        }
+        return object;
+    }
+}
+exports.RuleOperationCodecResult = RuleOperationCodecResult;
+class RuleOperationCodec {
+}
+exports.RuleOperationCodec = RuleOperationCodec;
+RuleOperationCodec.Query = new RuleOperationCodecQuery();
+RuleOperationCodec.Result = new RuleOperationCodecResult();

package/dist/xiot/core/spec/codec/ownership/DeviceOwnerCodec.d.ts

@@ -0,0 +1,7 @@
+import { DeviceOwner } from '../../typedef/ownership/DeviceOwner';
+export declare class DeviceOwnerCodec {
+    static decode(o: any): DeviceOwner;
+    static encode(x: DeviceOwner): any;
+    static decodeArray(arr: any[]): DeviceOwner[];
+    static encodeArray(x: DeviceOwner[]): any[];
+}

package/dist/xiot/core/spec/codec/ownership/DeviceOwnerCodec.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceOwnerCodec = void 0;
+const DeviceOwner_1 = require("../../typedef/ownership/DeviceOwner");
+class DeviceOwnerCodec {
+    static decode(o) {
+        const x = new DeviceOwner_1.DeviceOwner();
+        x.appId = o.appId;
+        x.ownerId = o.ownerId;
+        return x;
+    }
+    static encode(x) {
+        return {
+            appId: x.appId,
+            ownerId: x.ownerId
+        };
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.decode(o));
+            }
+        }
+        return list;
+    }
+    static encodeArray(x) {
+        const arr = [];
+        if (x === null || x === void 0 ? void 0 : x.length) {
+            for (const p of x) {
+                arr.push(this.encode(p));
+            }
+        }
+        return arr;
+    }
+}
+exports.DeviceOwnerCodec = DeviceOwnerCodec;

package/dist/xiot/core/spec/codec/ownership/OwnershipCodec.d.ts

@@ -0,0 +1,7 @@
+import { Ownership } from '../../typedef/ownership/Ownership';
+export declare class OwnershipCodec {
+    static decode(o: any): Ownership;
+    static encode(x: Ownership): any;
+    static decodeArray(arr: any[]): Ownership[];
+    static encodeArray(Ownerships: Ownership[]): any[];
+}

package/dist/xiot/core/spec/codec/ownership/OwnershipCodec.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnershipCodec = void 0;
+const Ownership_1 = require("../../typedef/ownership/Ownership");
+class OwnershipCodec {
+    static decode(o) {
+        const ownership = new Ownership_1.Ownership();
+        ownership.appId = o.appId;
+        ownership.ownerId = o.ownerId;
+        ownership.did = o.did;
+        ownership.token = o.token;
+        ownership.cloudId = o.cloudId;
+        ownership.rootId = o.rootId;
+        if (o.createAt !== undefined) {
+            ownership.createAt = new Date(o.createAt);
+        }
+        if (o.updateAt !== undefined) {
+            ownership.updateAt = new Date(o.updateAt);
+        }
+        return ownership;
+    }
+    static encode(x) {
+        const object = {
+            appId: x.appId,
+            ownerId: x.ownerId,
+            did: x.did,
+            token: x.token
+        };
+        if (x.cloudId != null) {
+            object.cloudId = x.cloudId;
+        }
+        if (x.rootId != null) {
+            object.rootId = x.rootId;
+        }
+        if (x.createAt != null) {
+            object.createAt = x.createAt.getTime();
+        }
+        if (x.updateAt != null) {
+            object.updateAt = x.updateAt.getTime();
+        }
+        return object;
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.decode(o));
+            }
+        }
+        return list;
+    }
+    static encodeArray(Ownerships) {
+        const arr = [];
+        if (Ownerships === null || Ownerships === void 0 ? void 0 : Ownerships.length) {
+            for (const p of Ownerships) {
+                arr.push(this.encode(p));
+            }
+        }
+        return arr;
+    }
+}
+exports.OwnershipCodec = OwnershipCodec;

package/dist/xiot/core/spec/codec/product/ProductCodec.d.ts

@@ -0,0 +1,7 @@
+import { Product } from '../../typedef/product/Product';
+export declare class ProductCodec {
+    static decode(o: any): Product;
+    static encode(x: Product): any;
+    static decodeArray(arr: any[]): Product[];
+    static encodeArray(products: Product[]): any[];
+}

package/dist/xiot/core/spec/codec/product/ProductCodec.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCodec = void 0;
+const Product_1 = require("../../typedef/product/Product");
+const DeviceType_1 = require("../../typedef/definition/urn/DeviceType");
+const VersionWithLifecycleCodec_1 = require("../lifecycle/product/VersionWithLifecycleCodec");
+class ProductCodec {
+    static decode(o) {
+        const x = new Product_1.Product();
+        x.id = o.id;
+        x.name = o.name;
+        x.icon = o.icon;
+        x.model = o.model;
+        x.template = new DeviceType_1.DeviceType(o.template);
+        x.organization = o.organization;
+        x.key = o.key;
+        x.cert = o.cert;
+        x.protocol = o.protocol;
+        x.createBy = o.createBy;
+        x.createAt = o.createAt;
+        x.updateBy = o.updateBy;
+        x.updateAt = o.updateAt;
+        if (o.versions && o.versions instanceof Array) {
+            x.versions = VersionWithLifecycleCodec_1.VersionWithLifecycleCodec.decodeArray(o.versions);
+        }
+        if (o.createAt !== undefined) {
+            x.createAt = new Date(o.createAt);
+        }
+        if (o.updateAt !== undefined) {
+            x.updateAt = new Date(o.updateAt);
+        }
+        return x;
+    }
+    static encode(x) {
+        let o = {
+            id: x.id,
+            name: x.name,
+            icon: x.icon,
+            model: x.model,
+            template: x.template.toString(),
+            organization: x.organization,
+            key: x.key,
+            cert: x.cert,
+            protocol: x.protocol,
+            createBy: x.createBy,
+            updateBy: x.updateBy,
+            versions: VersionWithLifecycleCodec_1.VersionWithLifecycleCodec.encodeArray(x.versions),
+        };
+        if (x.createAt !== undefined) {
+            o.createAt = x.createAt.getTime();
+        }
+        if (x.updateAt !== undefined) {
+            o.updateAt = x.updateAt.getTime();
+        }
+        return o;
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.decode(o));
+            }
+        }
+        return list;
+    }
+    static encodeArray(products) {
+        const arr = [];
+        if (products === null || products === void 0 ? void 0 : products.length) {
+            for (const p of products) {
+                arr.push(this.encode(p));
+            }
+        }
+        return arr;
+    }
+}
+exports.ProductCodec = ProductCodec;