@openxiot/xiot-core-spec-ts 0.0.3 → 0.0.6

package/dist/xiot/core/spec/codec/product/wizard/ProductWizardCodec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductWizardCodec = void 0;
+const ProductWizard_1 = require("../../../typedef/product/wizard/ProductWizard");
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const CreatorCodec_1 = require("../../by/CreatorCodec");
+const UpdaterCodec_1 = require("../../by/UpdaterCodec");
+class ProductWizardStepCodec {
+    static encode(x) {
+        return {
+            index: x.index,
+            image: x.image,
+            description: x.description,
+        };
+    }
+    static decode(x) {
+        if (x) {
+            return new ProductWizard_1.ProductWizardStep(x.index || 0, x.image || '', x.description || '');
+        }
+        return new ProductWizard_1.ProductWizardStep();
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    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;
+    }
+}
+class ProductWizardCodec {
+    static encode(x) {
+        let o = {
+            lifecycle: x.lifecycle.toString(),
+            steps: ProductWizardStepCodec.encodeArray(x.steps),
+        };
+        if (x.creator) {
+            o.creator = CreatorCodec_1.CreatorCodec.encode(x.creator);
+        }
+        if (x.updater) {
+            o.updater = UpdaterCodec_1.UpdaterCodec.encode(x.updater);
+        }
+        return o;
+    }
+    static decode(o) {
+        const x = new ProductWizard_1.ProductWizard();
+        if (o) {
+            x.lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || Lifecycle_1.LifeCycle.DEVELOPMENT);
+            x.steps = ProductWizardStepCodec.decodeArray(o.steps);
+            if (o.creator) {
+                x.creator = CreatorCodec_1.CreatorCodec.decode(o.creator);
+            }
+            if (o.updater) {
+                x.updater = UpdaterCodec_1.UpdaterCodec.decode(o.updater);
+            }
+        }
+        return x;
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    static decodeArray(arr) {
+        const instances = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                instances.push(this.decode(o));
+            }
+        }
+        return instances;
+    }
+}
+exports.ProductWizardCodec = ProductWizardCodec;

package/dist/xiot/core/spec/codec/version/GenericVersionCodec.d.ts

@@ -0,0 +1,5 @@
+import { GenericVersion } from "../../typedef/version/GenericVersion";
+export declare class GenericVersionCodec {
+    static encode(x: GenericVersion): any;
+    static decode(o: any): GenericVersion;
+}

package/dist/xiot/core/spec/codec/version/GenericVersionCodec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericVersionCodec = void 0;
+const GenericVersion_1 = require("../../typedef/version/GenericVersion");
+class GenericVersionCodec {
+    static encode(x) {
+        return {
+            name: x.name,
+            code: x.code
+        };
+    }
+    static decode(o) {
+        return new GenericVersion_1.GenericVersion(o.name || '', o.code || 0);
+    }
+}
+exports.GenericVersionCodec = GenericVersionCodec;

package/dist/xiot/core/spec/typedef/by/Creator.d.ts

@@ -0,0 +1,6 @@
+export declare class Creator {
+    id: string;
+    name: string;
+    timestamp: number;
+    constructor(id: string, name: string, timestamp: number);
+}

package/dist/xiot/core/spec/typedef/by/Creator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Creator = void 0;
+class Creator {
+    constructor(id, name, timestamp) {
+        this.id = id;
+        this.name = name;
+        this.timestamp = timestamp;
+    }
+}
+exports.Creator = Creator;

package/dist/xiot/core/spec/typedef/by/Updater.d.ts

@@ -0,0 +1,6 @@
+export declare class Updater {
+    id: string;
+    name: string;
+    timestamp: number;
+    constructor(id: string, name: string, timestamp: number);
+}

package/dist/xiot/core/spec/typedef/by/Updater.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Updater = void 0;
+class Updater {
+    constructor(id, name, timestamp) {
+        this.id = id;
+        this.name = name;
+        this.timestamp = timestamp;
+    }
+}
+exports.Updater = Updater;

package/dist/xiot/core/spec/typedef/instance/Action.d.ts

@@ -1,5 +1,7 @@
 import { ActionType } from '../definition/urn/ActionType';
 import { Argument } from './Argument';
+import { ActionOperation } from '../operation/ActionOperation';
+import { Property } from "./Property";
 export declare class Action {
     iid: number;
     type: ActionType;
@@ -11,4 +13,10 @@ export declare class Action {
     getArgumentsOut(): Argument[];
     addArgumentIn(arg: Argument): void;
     addArgumentOut(arg: Argument): void;
+    tryInvoke(o: ActionOperation, properties: Map<number, Property>): void;
+    private checkArgumentCount;
+    private checkArgumentValue;
+    private checkArgumentValueByCombinationValue;
+    private checkCombinationValue;
+    private checkArgumentValueByRawValue;
 }

package/dist/xiot/core/spec/typedef/instance/Action.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Action = void 0;
+const Status_1 = require("../status/Status");
+const DataFormat_1 = require("../definition/property/data/DataFormat");
 class Action {
     constructor(iid, type, description, argumentsIn, argumentsOut) {
         this.iid = 0;
@@ -29,5 +31,107 @@ class Action {
     addArgumentOut(arg) {
         this.out.set(arg.piid, arg);
     }
+    /*----------------------------------------------------------------------
+  * for debugger
+  *----------------------------------------------------------------------*/
+    tryInvoke(o, properties) {
+        o.status = Status_1.Status.COMPLETED;
+        for (const def of Array.from(this.in.values())) {
+            const arg = o.in.get(def.piid);
+            this.checkArgumentCount(o, arg, def);
+            if (o.isError()) {
+                break;
+            }
+            if (!arg) {
+                continue;
+            }
+            this.checkArgumentValue(o, arg, def, properties);
+            if (o.isError()) {
+                break;
+            }
+        }
+    }
+    checkArgumentCount(o, arg, def) {
+        if (arg === undefined) {
+            if (def.minRepeat > 0) {
+                o.status = Status_1.Status.ACTION_IN_ERROR;
+                o.description = "action in is null !";
+            }
+        }
+        else {
+            if (arg.values.length > def.maxRepeat) {
+                o.status = Status_1.Status.ACTION_IN_ERROR;
+                o.description = "action in.size() > maxRepeat !";
+            }
+        }
+    }
+    checkArgumentValue(o, arg, def, properties) {
+        const property = properties.get(def.piid);
+        if (property === undefined) {
+            o.status = Status_1.Status.INTERNAL_ERROR;
+            o.description = `找不到参数的属性定义: ${def.piid}`;
+            return;
+        }
+        if (property.format === DataFormat_1.DataFormat.COMBINATION) {
+            this.checkArgumentValueByCombinationValue(o, arg, def, property, properties);
+        }
+        else {
+            this.checkArgumentValueByRawValue(o, arg, def, property);
+        }
+    }
+    checkArgumentValueByCombinationValue(o, arg, def, property, properties) {
+        for (const argValue of arg.values) {
+            if (!(argValue instanceof Map)) {
+                o.status = Status_1.Status.ACTION_IN_VALUE_INVALID;
+                o.description = `combination value invalid: ${typeof argValue}`;
+                break;
+            }
+            this.checkCombinationValue(o, argValue, property, properties);
+            if (o.isError()) {
+                break;
+            }
+        }
+    }
+    checkCombinationValue(o, argValue, property, properties) {
+        for (const piid of property.members) {
+            const value = argValue.get(piid);
+            if (value === undefined || value === null) {
+                o.status = Status_1.Status.ACTION_IN_VALUE_INVALID;
+                o.description = `the member value in combination is null: piid: [${piid}]`;
+                break;
+            }
+            const member = properties.get(piid);
+            if (member === undefined) {
+                o.status = Status_1.Status.INTERNAL_ERROR;
+                o.description = `找不到组合参数的成员属性定义: ${piid}`;
+                break;
+            }
+            // 尝试写属性值，进行校验
+            if (!member.trySetValue(value)) {
+                o.status = Status_1.Status.PROPERTY_VALUE_INVALID;
+                o.description = `组合参数的成员属性值非法: piid: [${piid}], value: [${value}]`;
+                break;
+            }
+            // 如果argValue的值是浮点型，而property.value是整型，则帮argValue修正值为整型。布尔型不进行修正。
+            if (member.format !== DataFormat_1.DataFormat.BOOL) {
+                argValue.set(piid, value);
+            }
+            else {
+                // 当为bool类型，针对decimal数据做数据修复
+                // if (value instanceof BigDecimal) {
+                //   argValue.set(piid, (value as BigDecimal).intValue());
+                // }
+            }
+        }
+    }
+    checkArgumentValueByRawValue(o, arg, def, property) {
+        if (property.trySetValues(arg.values)) {
+            // 假设这里不需要额外处理
+        }
+        else {
+            o.status = Status_1.Status.ACTION_IN_VALUE_INVALID;
+            o.description = "action in value invalid, piid: " + def.piid;
+        }
+    }
 }
 exports.Action = Action;

package/dist/xiot/core/spec/typedef/product/basic/ProductBasic.d.ts

@@ -0,0 +1,19 @@
+import { Urn } from '../../definition/urn/Urn';
+import { Creator } from '../../by/Creator';
+import { Updater } from '../../by/Updater';
+import { LifeCycle } from '../../lifecycle/Lifecycle';
+export declare class ProductBasic {
+    id: number;
+    organization: string;
+    model: string;
+    template: Urn;
+    name: string;
+    icon: string;
+    upgrade: string[];
+    protocol: string;
+    lifecycle: LifeCycle;
+    naming: string[];
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(id: number | undefined, organization: string, model: string, template: Urn, name: string, icon: string, upgrade?: string[], protocol?: string, lifecycle?: LifeCycle, naming?: string[], creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/basic/ProductBasic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductBasic = void 0;
+const Lifecycle_1 = require("../../lifecycle/Lifecycle");
+class ProductBasic {
+    constructor(id = 0, organization, model, template, name, icon, upgrade = [], protocol = '', lifecycle = Lifecycle_1.LifeCycle.DEVELOPMENT, naming = [], creator = null, updater = null) {
+        this.id = id;
+        this.organization = organization;
+        this.model = model;
+        this.template = template;
+        this.name = name;
+        this.icon = icon;
+        this.upgrade = upgrade;
+        this.protocol = protocol;
+        this.lifecycle = lifecycle;
+        this.naming = naming;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductBasic = ProductBasic;

package/dist/xiot/core/spec/typedef/product/firmware/ProductFirmware.d.ts

@@ -0,0 +1,10 @@
+import { Creator } from "../../by/Creator";
+import { Updater } from "../../by/Updater";
+export declare class ProductFirmware {
+    name: string;
+    description: string;
+    type: string;
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(name?: string, description?: string, type?: string, creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/firmware/ProductFirmware.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductFirmware = void 0;
+class ProductFirmware {
+    constructor(name = '', description = '', type = '', creator = null, updater = null) {
+        this.name = name;
+        this.description = description;
+        this.type = type;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductFirmware = ProductFirmware;

package/dist/xiot/core/spec/typedef/product/firmware/ProductFirmwareInstance.d.ts

@@ -0,0 +1,21 @@
+import { GenericVersion } from "../../version/GenericVersion";
+import { LifeCycle } from "../../lifecycle/Lifecycle";
+import { Creator } from "../../by/Creator";
+import { Updater } from "../../by/Updater";
+export declare class FirmwareSample {
+    memo: string;
+    url: string;
+    size: number;
+    md5: string;
+    constructor(memo: string, url: string, size: number, md5: string);
+}
+export declare class ProductFirmwareInstance {
+    lifecycle: LifeCycle;
+    version: GenericVersion;
+    minUpgradeVersionCode: number;
+    type: string;
+    simple: FirmwareSample | null;
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(lifecycle: LifeCycle, version: GenericVersion, minUpgradeVersionCode: number, type: string, simple?: FirmwareSample | null, creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/firmware/ProductFirmwareInstance.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductFirmwareInstance = exports.FirmwareSample = void 0;
+class FirmwareSample {
+    constructor(memo, url, size, md5) {
+        this.memo = memo;
+        this.url = url;
+        this.size = size;
+        this.md5 = md5;
+    }
+}
+exports.FirmwareSample = FirmwareSample;
+class ProductFirmwareInstance {
+    constructor(lifecycle, version, minUpgradeVersionCode, type, simple = null, creator = null, updater = null) {
+        this.lifecycle = lifecycle;
+        this.version = version;
+        this.minUpgradeVersionCode = minUpgradeVersionCode;
+        this.type = type;
+        this.simple = simple;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductFirmwareInstance = ProductFirmwareInstance;

package/dist/xiot/core/spec/typedef/product/instance/ProductInstance.d.ts

@@ -0,0 +1,11 @@
+import { LifeCycle } from "../../lifecycle/Lifecycle";
+import { Urn } from "../../definition/urn/Urn";
+import { Creator } from "../../by/Creator";
+import { Updater } from "../../by/Updater";
+export declare class ProductInstance {
+    lifecycle: LifeCycle;
+    type: Urn | null;
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(lifecycle?: LifeCycle, type?: Urn | null, creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/instance/ProductInstance.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductInstance = void 0;
+const Lifecycle_1 = require("../../lifecycle/Lifecycle");
+class ProductInstance {
+    constructor(lifecycle = Lifecycle_1.LifeCycle.DEVELOPMENT, type = null, creator = null, updater = null) {
+        this.lifecycle = lifecycle;
+        this.type = type;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductInstance = ProductInstance;

package/dist/xiot/core/spec/typedef/product/manual/ProductManual.d.ts

@@ -0,0 +1,15 @@
+import { LifeCycle } from "../../lifecycle/Lifecycle";
+import { Creator } from "../../by/Creator";
+import { Updater } from "../../by/Updater";
+export declare class ProductManualPage {
+    index: number;
+    url: string;
+    constructor(index?: number, url?: string);
+}
+export declare class ProductManual {
+    pages: ProductManualPage[];
+    lifecycle: LifeCycle;
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(pages?: ProductManualPage[], lifecycle?: LifeCycle, creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/manual/ProductManual.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductManual = exports.ProductManualPage = void 0;
+const Lifecycle_1 = require("../../lifecycle/Lifecycle");
+class ProductManualPage {
+    constructor(index = 0, url = '') {
+        this.index = index;
+        this.url = url;
+    }
+}
+exports.ProductManualPage = ProductManualPage;
+class ProductManual {
+    constructor(pages = [], lifecycle = Lifecycle_1.LifeCycle.DEVELOPMENT, creator = null, updater = null) {
+        this.pages = pages;
+        this.lifecycle = lifecycle;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductManual = ProductManual;

package/dist/xiot/core/spec/typedef/product/panel/ProductPanel.d.ts

@@ -0,0 +1,27 @@
+import { LifeCycle } from "../../lifecycle/Lifecycle";
+import { Creator } from "../../by/Creator";
+import { Updater } from "../../by/Updater";
+import { GenericVersion } from "../../version/GenericVersion";
+import { Urn } from "../../definition/urn/Urn";
+export declare class ProductPanelWeb {
+    format: string;
+    url: string;
+    constructor(format: string, url: string);
+}
+export declare class ProductPanelMiniApp {
+    appId: string;
+    constructor(appId: string);
+}
+export declare class ProductPanel {
+    status: string;
+    lifecycle: LifeCycle;
+    category: string;
+    type: string;
+    web: ProductPanelWeb | null;
+    miniapp: ProductPanelMiniApp | null;
+    version: GenericVersion;
+    instance: Urn;
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(status: string, lifecycle: LifeCycle | undefined, category: string, type: string, web: ProductPanelWeb | null, miniapp: ProductPanelMiniApp | null, version: GenericVersion, instance: Urn, creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/panel/ProductPanel.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductPanel = exports.ProductPanelMiniApp = exports.ProductPanelWeb = void 0;
+const Lifecycle_1 = require("../../lifecycle/Lifecycle");
+class ProductPanelWeb {
+    constructor(format, url) {
+        this.format = format;
+        this.url = url;
+    }
+}
+exports.ProductPanelWeb = ProductPanelWeb;
+class ProductPanelMiniApp {
+    constructor(appId) {
+        this.appId = appId;
+    }
+}
+exports.ProductPanelMiniApp = ProductPanelMiniApp;
+class ProductPanel {
+    constructor(status, lifecycle = Lifecycle_1.LifeCycle.DEVELOPMENT, category, type, web, miniapp, version, instance, creator = null, updater = null) {
+        this.status = status;
+        this.lifecycle = lifecycle;
+        this.category = category;
+        this.type = type;
+        this.web = web;
+        this.miniapp = miniapp;
+        this.version = version;
+        this.instance = instance;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductPanel = ProductPanel;

package/dist/xiot/core/spec/typedef/product/wizard/ProductWizard.d.ts

@@ -0,0 +1,16 @@
+import { LifeCycle } from "../../lifecycle/Lifecycle";
+import { Creator } from "../../by/Creator";
+import { Updater } from "../../by/Updater";
+export declare class ProductWizardStep {
+    index: number;
+    image: string;
+    description: string;
+    constructor(index?: number, image?: string, description?: string);
+}
+export declare class ProductWizard {
+    steps: ProductWizardStep[];
+    lifecycle: LifeCycle;
+    creator: Creator | null;
+    updater: Updater | null;
+    constructor(steps?: ProductWizardStep[], lifecycle?: LifeCycle, creator?: Creator | null, updater?: Updater | null);
+}

package/dist/xiot/core/spec/typedef/product/wizard/ProductWizard.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductWizard = exports.ProductWizardStep = void 0;
+const Lifecycle_1 = require("../../lifecycle/Lifecycle");
+class ProductWizardStep {
+    constructor(index = 0, image = '', description = '') {
+        this.index = index;
+        this.image = image;
+        this.description = description;
+    }
+}
+exports.ProductWizardStep = ProductWizardStep;
+class ProductWizard {
+    constructor(steps = [], lifecycle = Lifecycle_1.LifeCycle.DEVELOPMENT, creator = null, updater = null) {
+        this.steps = steps;
+        this.lifecycle = lifecycle;
+        this.creator = creator;
+        this.updater = updater;
+    }
+}
+exports.ProductWizard = ProductWizard;

package/dist/xiot/core/spec/typedef/version/GenericVersion.d.ts

@@ -0,0 +1,5 @@
+export declare class GenericVersion {
+    name: string;
+    code: number;
+    constructor(name: string, code: number);
+}

package/dist/xiot/core/spec/typedef/version/GenericVersion.js

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

package/dist/xiot/core/spec/typedef/version/{Version.d.ts → SemanticVersion.d.ts}

@@ -1,9 +1,8 @@
-export declare class Version {
+export declare class SemanticVersion {
     major: number;
     minor: number;
     patch: number;
     constructor(major: number, minor: number, patch: number);
-    static fromString(version: string): Version;
+    static fromString(version: string): SemanticVersion;
     toString(): string;
-    greaterThan(other: Version): boolean;
 }

package/dist/xiot/core/spec/typedef/version/SemanticVersion.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticVersion = void 0;
+class SemanticVersion {
+    constructor(major, minor, patch) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+    }
+    static fromString(version) {
+        const s = version.split('.');
+        const x = Number.parseInt(s[0]);
+        const y = Number.parseInt(s[1]);
+        const z = Number.parseInt(s[2]);
+        return new SemanticVersion(x, y, z);
+    }
+    toString() {
+        return `${this.major}.${this.minor}.${this.patch}`;
+    }
+}
+exports.SemanticVersion = SemanticVersion;

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@openxiot/xiot-core-spec-ts",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "XIOT Specification Codec",
   "main": "dist/index.js",
-  "module": "dist/index.esm.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
-      "import": "./dist/index.esm.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [

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

@@ -1,7 +0,0 @@
-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[];
-}