@project-chip/matter.js 0.0.2 → 0.1.0

package/dist/es/common/ClusterId.js

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt32 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Cluster Identifier is a 32 bit number and SHALL reference a single cluster specification and
+ * SHALL define conformance to that specification.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 7.10
+ */
+export class ClusterId {
+    constructor(id) {
+        this.id = id;
+    }
+}
+/** Tlv schema for a cluster Id. */
+export const TlvClusterId = new TlvWrapper(TlvUInt32, clusterId => clusterId.id, value => new ClusterId(value));

package/dist/es/common/DeviceTypeId.js

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt32 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Device type ID is a 32-bit number that defines the type of the device.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 7.15
+ */
+export class DeviceTypeId {
+    constructor(id) {
+        this.id = id;
+    }
+}
+/** Tlv schema for a Device type ID. */
+export const TlvDeviceTypeId = new TlvWrapper(TlvUInt32, deviceTypeId => deviceTypeId.id, value => new DeviceTypeId(value));

package/dist/es/common/EndpointNumber.js

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt16 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Endpoint Number is a 16-bit number that that indicates an instance of a device type.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 7.18.2.11
+ */
+export class EndpointNumber {
+    constructor(number) {
+        this.number = number;
+    }
+}
+/** Tlv schema for an Endpoint number. */
+export const TlvEndpointNumber = new TlvWrapper(TlvUInt16, endpointNumber => endpointNumber.number, value => new EndpointNumber(value));

package/dist/es/common/FabricId.js

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt64 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Fabric ID is a 64-bit number that uniquely identifies the Fabric within the scope of
+ * a particular root CA.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 2.5.1
+ */
+export class FabricId {
+    constructor(id) {
+        this.id = id;
+    }
+}
+/** Tlv schema for a Node Identifier. */
+export const TlvFabricId = new TlvWrapper(TlvUInt64, fabricId => fabricId.id, value => new FabricId(BigInt(value)));

package/dist/es/common/FabricIndex.js

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt8 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * Each fabric supported on a node is referenced by fabric-index that is unique on the node. This
+ * fabric-index enables the look-up of the full fabric information from the fabric-index. A fabric-index
+ * of 0 (zero) or null SHALL indicate that there is no fabric associated with the context in which the
+ * fabric-index is being used. If fabric-index is used in a context that is exclusively associated with
+ * a fabric, such as fabric-scoped data model elements, then the fabric-index values SHALL NOT include 0
+ * (zero) or null.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 7.5.2
+ */
+export class FabricIndex {
+    constructor(index) {
+        this.index = index;
+    }
+}
+/** Tlv Schema for a Fabric Index. */
+export const TlvFabricIndex = new TlvWrapper(TlvUInt8.bound({ min: 1, max: 254 }), farbricIndex => farbricIndex.index, value => new FabricIndex(value));

package/dist/es/common/GroupId.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt16 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Group Identifier (Group ID or GID) is a 16-bit number that identifies a set of Nodes across a
+ * Fabric at the message layer (see Section 4.15, “Group Key Management”). A Group ID can further
+ * be bound to one or more Endpoints within each Node in the group at the interaction layer.
+ *
+ * The Group ID space is allocated as described in Table 2, “Group ID Allocations”:
+ * 0x0000 - Null or unspecified Group ID
+ * 0x0001 - 0xFEFF: Application Group ID, assigned by fabric Administrator
+ * 0xFF00 - 0xFFFF: Universal Group ID range reserved for static multicast and anycast identifiers
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 2.5.4
+ */
+export class GroupId {
+    constructor(id) {
+        this.id = id;
+    }
+}
+/** Tlv Schema for a Group Id. */
+export const TlvGroupId = new TlvWrapper(TlvUInt16, groupId => groupId.id, value => new GroupId(value));

package/dist/es/common/NodeId.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt64 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+import { Endian } from "../util/ByteArray.js";
+import { DataWriter } from "../util/DataWriter.js";
+/**
+ * A Node Identifier (Node ID) is a 64-bit number that uniquely identifies an individual Node or a
+ * group of Nodes on a Fabric.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 2.5.5
+ */
+export class NodeId {
+    constructor(id) {
+        this.id = id;
+    }
+    toString() {
+        const writer = new DataWriter(Endian.Big);
+        writer.writeUInt64(this.id);
+        return writer.toByteArray().toHex().toUpperCase();
+    }
+}
+/** Tlv schema for a Node Identifier. */
+export const TlvNodeId = new TlvWrapper(TlvUInt64, nodeId => nodeId.id, value => new NodeId(BigInt(value)));

package/dist/es/common/SubjectId.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvNodeId } from "./NodeId.js";
+/** Tlv schema for a Subject Id */
+export const TlvSubjectId = TlvNodeId;

package/dist/es/common/VendorId.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvUInt16 } from "../tlv/TlvNumber.js";
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * A Vendor Identifier (Vendor ID or VID) is a 16-bit number that uniquely identifies a particular
+ * product manufacturer, vendor, or group thereof. Each Vendor ID is statically allocated by the
+ * Connectivity Standards Alliance (see [CSA Manufacturer Code Database]).
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 2.5.2
+ */
+export class VendorId {
+    constructor(id) {
+        this.id = id;
+    }
+}
+/** Data model for a Vendor Identifier. */
+export const TlvVendorId = new TlvWrapper(TlvUInt16, vendorId => vendorId.id, value => new VendorId(value));

package/dist/{matter.js → es/matter.js}

@@ -20,3 +20,15 @@ export * from "./tlv/TlvString.js";
 export * from "./tlv/TlvNumber.js";
 export * from "./tlv/TlvVoid.js";
 export * from "./tlv/TlvWrapper.js";
+export * from "./cluster/AccessControlCluster.js";
+export * from "./cluster/BasicInformationCluster.js";
+export * from "./cluster/BindingCluster.js";
+export * from "./cluster/BridgedDeviceBasicInformationCluster.js";
+export * from "./cluster/DescriptorCluster.js";
+export * from "./cluster/GeneralCommissioningCluster.js";
+export * from "./cluster/GroupsCluster.js";
+export * from "./cluster/IdentifyCluster.js";
+export * from "./cluster/LabelCluster.js";
+export * from "./cluster/OnOffCluster.js";
+export * from "./cluster/OperationalCredentialsCluster.js";
+export * from "./cluster/ScenesCluster.js";

package/dist/es/protocol/InteractionProtocol.js

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvNodeId } from "../common/NodeId.js";
+import { TlvAny } from "../tlv/TlvAny.js";
+import { TlvArray } from "../tlv/TlvArray.js";
+import { TlvBoolean } from "../tlv/TlvBoolean.js";
+import { TlvEnum, TlvUInt16, TlvUInt32, TlvUInt64, TlvUInt8 } from "../tlv/TlvNumber.js";
+import { TlvField, TlvList, TlvObject, TlvOptionalField } from "../tlv/TlvObject.js";
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.1. StatusResponseMessage
+ */
+export const TlvStatusResponse = TlvObject({
+    status: TlvField(0, TlvEnum()),
+    interactionModelRevision: TlvField(0xFF, TlvUInt8),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.5.2. AttributePathIB
+ */
+const TlvAttributePath = TlvList({
+    endpointId: TlvOptionalField(2, TlvUInt16),
+    clusterId: TlvOptionalField(3, TlvUInt32),
+    id: TlvOptionalField(4, TlvUInt32),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.2. ReadRequestMessage
+ */
+export const TlvReadRequest = TlvObject({
+    attributes: TlvField(0, TlvArray(TlvAttributePath)),
+    isFabricFiltered: TlvField(3, TlvBoolean),
+    interactionModelRevision: TlvField(0xFF, TlvUInt8),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.3. ReportDataMessage
+ */
+export const TlvReportData = TlvObject({
+    subscriptionId: TlvOptionalField(0, TlvUInt32),
+    values: TlvField(1, TlvArray(TlvObject({
+        value: TlvField(1, TlvObject({
+            version: TlvField(0, TlvUInt32),
+            path: TlvField(1, TlvList({
+                endpointId: TlvField(2, TlvUInt16),
+                clusterId: TlvField(3, TlvUInt32),
+                id: TlvField(4, TlvUInt32),
+            })),
+            value: TlvField(2, TlvAny),
+        })),
+    }))),
+    isFabricFiltered: TlvOptionalField(4, TlvBoolean),
+    interactionModelRevision: TlvField(0xFF, TlvUInt8),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.4. SubscribeRequestMessage
+ */
+export const TlvSubscribeRequest = TlvObject({
+    keepSubscriptions: TlvField(0, TlvBoolean),
+    minIntervalFloorSeconds: TlvField(1, TlvUInt16),
+    maxIntervalCeilingSeconds: TlvField(2, TlvUInt16),
+    attributeRequests: TlvOptionalField(3, TlvArray(TlvAttributePath)),
+    eventRequests: TlvOptionalField(4, TlvArray(TlvList({
+        node: TlvField(0, TlvNodeId),
+        endpoint: TlvField(1, TlvUInt16),
+        cluster: TlvField(2, TlvUInt32),
+        event: TlvField(3, TlvUInt32),
+        isUrgent: TlvField(4, TlvBoolean),
+    }))),
+    eventFilters: TlvOptionalField(5, TlvArray(TlvList({
+        node: TlvField(0, TlvNodeId),
+        eventMin: TlvField(1, TlvUInt64),
+    }))),
+    isFabricFiltered: TlvField(7, TlvBoolean),
+    dataVersionFilters: TlvOptionalField(8, TlvArray(TlvObject({
+        path: TlvField(0, TlvList({
+            node: TlvField(0, TlvNodeId),
+            endpoint: TlvField(1, TlvUInt16),
+            cluster: TlvField(2, TlvUInt32),
+        })),
+        dataVersion: TlvField(1, TlvUInt32),
+    }))),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.5. SubscribeResponseMessage
+ */
+export const TlvSubscribeResponse = TlvObject({
+    subscriptionId: TlvField(0, TlvUInt32),
+    maxIntervalCeilingSeconds: TlvField(2, TlvUInt16),
+    interactionModelRevision: TlvField(0xFF, TlvUInt8),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.9. InvokeRequestMessage
+ */
+export const TlvInvokeRequest = TlvObject({
+    suppressResponse: TlvField(0, TlvBoolean),
+    timedRequest: TlvField(1, TlvBoolean),
+    invokes: TlvField(2, TlvArray(TlvObject({
+        path: TlvField(0, TlvList({
+            endpointId: TlvField(0, TlvUInt16),
+            clusterId: TlvField(1, TlvUInt32),
+            id: TlvField(2, TlvUInt32),
+        })),
+        args: TlvField(1, TlvAny),
+    }))),
+    interactionModelRevision: TlvField(0xFF, TlvUInt8),
+});
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.10. InvokeResponseMessage
+ */
+export const TlvInvokeResponse = TlvObject({
+    suppressResponse: TlvField(0, TlvBoolean),
+    responses: TlvField(1, TlvArray(TlvObject({
+        response: TlvOptionalField(0, TlvObject({
+            path: TlvField(0, TlvList({
+                endpointId: TlvField(0, TlvUInt16),
+                clusterId: TlvField(1, TlvUInt32),
+                id: TlvField(2, TlvUInt32),
+            })),
+            response: TlvField(1, TlvAny),
+        })),
+        result: TlvOptionalField(1, TlvObject({
+            path: TlvField(0, TlvList({
+                endpointId: TlvField(0, TlvUInt16),
+                clusterId: TlvField(1, TlvUInt32),
+                id: TlvField(2, TlvUInt32),
+            })),
+            result: TlvField(1, TlvObject({
+                code: TlvField(0, TlvUInt16),
+            })),
+        })),
+    }))),
+    interactionModelRevision: TlvField(0xFF, TlvUInt8),
+});

package/dist/es/schema/BitmapSchema.js

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../util/ByteArray";
+import { Schema } from "./Schema";
+const BitRange = (type, offset, length) => ({ type, offset, length });
+export const BitFlag = (offset) => BitRange(0 /* BitRangeType.Flag */, offset, 1);
+export const BitField = (offset, length) => BitRange(1 /* BitRangeType.Number */, offset, length);
+export const BitFieldEnum = (offset, length) => BitRange(2 /* BitRangeType.Enum */, offset, length);
+class BitmapSchemaInternal extends Schema {
+    constructor(bitSchemas) {
+        super();
+        this.bitSchemas = bitSchemas;
+        const masks = {};
+        for (const name in this.bitSchemas) {
+            const { offset, length } = this.bitSchemas[name];
+            masks[name] = ((1 << length) - 1) << offset;
+        }
+        this.masks = masks;
+        // TODO: validate that bitSchemas is coherent
+    }
+    encodeInternal(value) {
+        let result = 0;
+        for (const name in this.bitSchemas) {
+            const { type, offset } = this.bitSchemas[name];
+            switch (type) {
+                case 0 /* BitRangeType.Flag */:
+                    if (value[name])
+                        result |= this.masks[name];
+                    break;
+                case 2 /* BitRangeType.Enum */:
+                case 1 /* BitRangeType.Number */:
+                    result |= value[name] << offset;
+            }
+        }
+        return result;
+    }
+    decodeInternal(bitmap) {
+        const result = {};
+        for (const name in this.bitSchemas) {
+            const { type, offset } = this.bitSchemas[name];
+            const mask = this.masks[name];
+            if (type === 0 /* BitRangeType.Flag */) {
+                result[name] = (bitmap & mask) !== 0;
+            }
+            else {
+                result[name] = (bitmap & mask) >> offset;
+            }
+        }
+        return result;
+    }
+}
+class ByteArrayBitmapSchemaInternal extends Schema {
+    constructor(bitSchemas) {
+        super();
+        this.bitSchemas = bitSchemas;
+        let maxBitLength = 0;
+        const maskOffset = {};
+        for (const name in this.bitSchemas) {
+            const { offset, length } = this.bitSchemas[name];
+            const bitOffset = offset % 8;
+            const byteOffset = (offset - bitOffset) / 8;
+            const mask = ((1 << length) - 1) << bitOffset;
+            maskOffset[name] = { bitOffset, byteOffset, mask };
+            maxBitLength = Math.max(maxBitLength, offset + length);
+        }
+        this.byteArrayLength = Math.ceil(maxBitLength / 8);
+        this.maskOffset = maskOffset;
+    }
+    encodeInternal(value) {
+        let result = new ByteArray(this.byteArrayLength);
+        for (const name in this.bitSchemas) {
+            const { type } = this.bitSchemas[name];
+            let { mask, bitOffset, byteOffset } = this.maskOffset[name];
+            switch (type) {
+                case 0 /* BitRangeType.Flag */:
+                    if (value[name])
+                        result[byteOffset] |= mask;
+                    break;
+                case 2 /* BitRangeType.Enum */:
+                case 1 /* BitRangeType.Number */:
+                    let numValue = value[name];
+                    while (mask !== 0) {
+                        result[byteOffset++] |= ((numValue & mask) << bitOffset) & 0xFF;
+                        const bitWritten = 8 - bitOffset;
+                        bitOffset = 0;
+                        numValue = numValue >> bitWritten;
+                        mask = mask >> 8;
+                    }
+            }
+        }
+        return result;
+    }
+    decodeInternal(bitmap) {
+        if (bitmap.length !== this.byteArrayLength)
+            throw new Error(`Unexpected length: ${bitmap.length}. Expected ${this.byteArrayLength}`);
+        const result = {};
+        for (const name in this.bitSchemas) {
+            const { type } = this.bitSchemas[name];
+            let { mask, bitOffset, byteOffset } = this.maskOffset[name];
+            if (type === 0 /* BitRangeType.Flag */) {
+                result[name] = (bitmap[byteOffset] & mask) !== 0;
+            }
+            else {
+                let value = 0;
+                let valueBitOffset = 0;
+                while (mask !== 0) {
+                    value |= ((bitmap[byteOffset++] & mask) >> bitOffset) << valueBitOffset;
+                    const bitWritten = 8 - bitOffset;
+                    bitOffset = 0;
+                    valueBitOffset += bitWritten;
+                    mask = mask >> 8;
+                }
+                result[name] = value;
+            }
+        }
+        return result;
+    }
+}
+/** Declares a bitmap schema by indicating the bit position and their names. */
+export const BitmapSchema = (bitSchemas) => new BitmapSchemaInternal(bitSchemas);
+/** Declares a bitmap schema backed by a ByteArray by indicating the bit position and their names. */
+export const ByteArrayBitmapSchema = (bitSchemas) => new ByteArrayBitmapSchemaInternal(bitSchemas);

package/dist/{tlv → es/tlv}/TlvObject.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { TlvSchema } from "./TlvSchema.js";
+import { TlvAny } from "./TlvAny.js";
 ;
 /**
  * Schema to encode an object in TLV.
@@ -48,8 +49,11 @@ export class ObjectSchema extends TlvSchema {
             if (id === undefined)
                 throw new Error("Structure element tags should have an id.");
             const fieldName = this.fieldById[id];
-            if (fieldName === undefined)
-                throw new Error(`Unknown field ${id}`);
+            if (fieldName === undefined) {
+                // Ignore unknown field by decoding it as raw TLV so we skip forward the proper length.
+                TlvAny.decodeTlvInternalValue(reader, elementTypeLength);
+                continue;
+            }
             const { field, name } = fieldName;
             result[name] = field.schema.decodeTlvInternalValue(reader, elementTypeLength);
         }

package/dist/{util → es/util}/ByteArray.js

@@ -16,6 +16,8 @@ Uint8Array.prototype.equals = function (other) {
 };
 Uint8Array.fromHex = function (hexString) {
     var _a;
+    if (hexString.length === 0)
+        return new ByteArray(0);
     if (hexString.length % 2 !== 0)
         throw new Error("Hex string should have an even length.");
     const bytes = (_a = hexString.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map(byteHex => parseInt(byteHex, 16));

package/dist/{util → es/util}/Type.js

@@ -3,4 +3,4 @@
  * Copyright 2022 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-export {};
+export const Merge = (a, b) => (Object.assign(Object.assign({}, a), b));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@project-chip/matter.js",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Matter protocol in pure js",
   "keywords": [
     "iot",
@@ -23,8 +23,8 @@
     "url": "https://github.com/project-chip/matter.js.git"
   },
   "scripts": {
-    "clean": "rm -rf dist; rm -rf dist-cjs",
-    "build": "npm run clean; tsc --project tsconfig.dist.json; tsc --project tsconfig.dist-cjs.json",
+    "clean": "rm -rf dist; rm -rf out",
+    "build": "npm run clean; tsc --project tsconfig.dist-es.json; tsc --project tsconfig.dist-cjs.json; tsc --project tsconfig.dist-dts.json",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test-web": "karma start karma.conf.cjs"
   },
@@ -40,10 +40,9 @@
     "typescript": "^4.9.3"
   },
   "files": [
-    "dist/**/*",
-    "dist-cjs/**/*"
+    "dist/**/*"
   ],
-  "main": "dist-cjs/matter.js",
-  "module": "dist/matter.js",
-  "types": "dist/matter.d.ts"
+  "main": "dist/cjs/matter.js",
+  "module": "dist/es/matter.js",
+  "types": "dist/dts/matter.d.ts"
 }

package/dist/schema/BitmapSchema.js

@@ -1,48 +0,0 @@
-/**
- * @license
- * Copyright 2022 Project CHIP Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Schema } from "./Schema.js";
-const BitRange = (type, offset, length) => ({ type, mask: ((1 << length) - 1) << offset, offset });
-export const BitFlag = (offset) => BitRange(0 /* BitRangeType.Flag */, offset, 1);
-export const BitField = (offset, length) => BitRange(1 /* BitRangeType.Number */, offset, length);
-export const BitFieldEnum = (offset, length) => BitRange(2 /* BitRangeType.Enum */, offset, length);
-class BitmapSchemaInternal extends Schema {
-    constructor(bitSchemas) {
-        super();
-        this.bitSchemas = bitSchemas;
-        // TODO: validate that bitSchemas is coherent
-    }
-    encodeInternal(value) {
-        let result = 0;
-        for (const name in this.bitSchemas) {
-            const { type, offset, mask } = this.bitSchemas[name];
-            switch (type) {
-                case 0 /* BitRangeType.Flag */:
-                    if (value[name])
-                        result |= mask;
-                    break;
-                case 2 /* BitRangeType.Enum */:
-                case 1 /* BitRangeType.Number */:
-                    result |= value[name] << offset;
-            }
-        }
-        return result;
-    }
-    decodeInternal(bitmap) {
-        const result = {};
-        for (const name in this.bitSchemas) {
-            const { type, offset, mask } = this.bitSchemas[name];
-            if (type === 0 /* BitRangeType.Flag */) {
-                result[name] = (bitmap & mask) !== 0;
-            }
-            else {
-                result[name] = (bitmap & mask) >> offset;
-            }
-        }
-        return result;
-    }
-}
-/** Declares a bitmap schema by indicating the bit position and their names. */
-export const BitmapSchema = (bitSchemas) => new BitmapSchemaInternal(bitSchemas);