@project-chip/matter.js 0.0.2 → 0.1.0

package/dist/dts/cluster/ScenesCluster.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, OptionalAttribute, Cluster, Command, OptionalCommand } from "./Cluster.js";
+import { BitFlag } from "../schema/BitmapSchema.js";
+import { StatusCode } from "../protocol/InteractionProtocol.js";
+/**
+ * This data type indicates for a given cluster a set of attributes and their values. Only attributes which
+ * have the "S" designation in the Quality column of the cluster specification SHALL be used in the
+ * AttributeValueList field.
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 1.4.6.2
+ */
+export declare const TlvExtensionFieldSet: import("../tlv/TlvObject.js").ObjectSchema<{
+    clusterId: import("../tlv/TlvObject.js").FieldType<import("../common/ClusterId.js").ClusterId>;
+    attributeValueList: import("../tlv/TlvObject.js").FieldType<{
+        attributeId: import("../common/AttributeId.js").AttributeId;
+        attributeValue: import("../matter.js").TlvStream[];
+    }[]>;
+}>;
+/**
+ * The Scenes cluster provides attributes and commands for setting up and recalling scenes.
+ * Each scene corresponds to a set of stored values of specified attributes for one or more
+ * clusters on the same end point as the Scenes cluster.
+ *
+ * @see {@link MatterApplicationClusterSpecificationV1_0} § 1.4
+ */
+export declare const ScenesCluster: Cluster<{
+    /** The ability to store a name for a scene. */
+    sceneNames: BitFlag;
+}, {
+    sceneCount: Attribute<number>;
+    currentScene: Attribute<number>;
+    currentGroup: Attribute<number>;
+    sceneValid: Attribute<boolean>;
+    nameSupport: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<{
+        sceneNames: BitFlag;
+    }>>;
+    lastConfiguredBy: OptionalAttribute<import("../common/NodeId.js").NodeId | null>;
+    clusterRevision: Attribute<number>;
+    featureMap: Attribute<import("../schema/BitmapSchema.js").TypeFromBitSchema<{
+        /** The ability to store a name for a scene. */
+        sceneNames: BitFlag;
+    }>>;
+}, {
+    /**
+     * Add a scene to the scene table.
+     * Extension field sets are supported, and are inputed as
+     * '{"ClusterID": VALUE, "AttributeValueList":[{"AttributeId": VALUE, "AttributeValue": VALUE}]}'
+     */
+    addScene: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+        transitionTime: number;
+        sceneName: string;
+        extensionFieldSets: {
+            clusterId: import("../common/ClusterId.js").ClusterId;
+            attributeValueList: {
+                attributeId: import("../common/AttributeId.js").AttributeId;
+                attributeValue: import("../matter.js").TlvStream[];
+            }[];
+        }[];
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }>;
+    /**
+     * Retrieves the requested scene entry from its Scene table.
+     */
+    viewScene: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+        transitionTime?: number | undefined;
+        sceneName?: string | undefined;
+        extensionFieldSets?: {
+            clusterId: import("../common/ClusterId.js").ClusterId;
+            attributeValueList: {
+                attributeId: import("../common/AttributeId.js").AttributeId;
+                attributeValue: import("../matter.js").TlvStream[];
+            }[];
+        }[] | undefined;
+    }>;
+    /**
+     * Removes the requested scene entry, corresponding to the value of the GroupID field, from its Scene Table
+     */
+    removeScene: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }>;
+    /**
+     * Remove all scenes, corresponding to the value of the GroupID field, from its Scene Table
+     */
+    removeAllScenes: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+    }>;
+    /**
+     * Adds the scene entry into its Scene Table along with all extension field sets corresponding to the current
+     * state of other clusters on the same endpoint
+     */
+    storeScenes: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }>;
+    /**
+     * Set the attributes and corresponding state for each other cluster implemented on the endpoint accordingly to
+     * the requested scene entry in the Scene Table
+     */
+    recallScene: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+        transitionTime?: number | null | undefined;
+    }, void>;
+    /**
+     * Get an unused scene identifier when no commissioning tool is in the network, or for a commissioning tool to
+     * get the used scene identifiers within a certain group
+     */
+    getSceneMembership: Command<{
+        groupId: import("../common/GroupId.js").GroupId;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        capacity: number | null;
+        sceneList?: number[] | undefined;
+    }>;
+    /**
+     * Allows a scene to be added using a finer scene transition time than the AddScene command.
+     */
+    enhancedAddScene: OptionalCommand<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+        transitionTime: number;
+        sceneName: string;
+        extensionFieldSets: {
+            clusterId: import("../common/ClusterId.js").ClusterId;
+            attributeValueList: {
+                attributeId: import("../common/AttributeId.js").AttributeId;
+                attributeValue: import("../matter.js").TlvStream[];
+            }[];
+        }[];
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }>;
+    /**
+     * Allows a scene to be retrieved using a finer scene transition time than the ViewScene command
+     */
+    enhancedViewScene: OptionalCommand<{
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+    }, {
+        status: StatusCode;
+        groupId: import("../common/GroupId.js").GroupId;
+        sceneId: number;
+        transitionTime?: number | undefined;
+        sceneName?: string | undefined;
+        extensionFieldSets?: {
+            clusterId: import("../common/ClusterId.js").ClusterId;
+            attributeValueList: {
+                attributeId: import("../common/AttributeId.js").AttributeId;
+                attributeValue: import("../matter.js").TlvStream[];
+            }[];
+        }[] | undefined;
+    }>;
+    /**
+     * Allows a client to efficiently copy scenes from one group/scene identifier pair to another group/scene
+     * identifier pair.
+     */
+    copyScene: OptionalCommand<{
+        mode: import("../schema/BitmapSchema.js").TypeFromBitSchema<{
+            copyAllScenes: BitFlag;
+        }>;
+        groupIdFrom: import("../common/GroupId.js").GroupId;
+        sceneIdFrom: number;
+        TlvGroupIdo: import("../common/GroupId.js").GroupId;
+        sceneIdTo: number;
+    }, {
+        status: StatusCode;
+        groupIdFrom: import("../common/GroupId.js").GroupId;
+        sceneIdFrom: number;
+    }>;
+}, import("./Cluster.js").Events>;

package/dist/dts/common/AttributeId.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvWrapper } from "../tlv/TlvWrapper.js";
+/**
+ * An Attribute ID is a 32 bit number and indicates an attribute defined in a cluster specification.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 7.18.2.15
+ */
+export declare class AttributeId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Tlv schema for an Attribute Id. */
+export declare const TlvAttributeId: TlvWrapper<AttributeId, number>;

package/dist/dts/common/ClusterId.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class ClusterId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Tlv schema for a cluster Id. */
+export declare const TlvClusterId: TlvWrapper<ClusterId, number>;

package/dist/dts/common/DeviceTypeId.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class DeviceTypeId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Tlv schema for a Device type ID. */
+export declare const TlvDeviceTypeId: TlvWrapper<DeviceTypeId, number>;

package/dist/dts/common/EndpointNumber.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class EndpointNumber {
+    readonly number: number;
+    constructor(number: number);
+}
+/** Tlv schema for an Endpoint number. */
+export declare const TlvEndpointNumber: TlvWrapper<EndpointNumber, number>;

package/dist/dts/common/FabricId.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class FabricId {
+    readonly id: bigint;
+    constructor(id: bigint);
+}
+/** Tlv schema for a Node Identifier. */
+export declare const TlvFabricId: TlvWrapper<FabricId, number | bigint>;

package/dist/dts/common/FabricIndex.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class FabricIndex {
+    readonly index: number;
+    constructor(index: number);
+}
+/** Tlv Schema for a Fabric Index. */
+export declare const TlvFabricIndex: TlvWrapper<FabricIndex, number>;

package/dist/dts/common/GroupId.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class GroupId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Tlv Schema for a Group Id. */
+export declare const TlvGroupId: TlvWrapper<GroupId, number>;

package/dist/dts/common/NodeId.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvWrapper } from "../tlv/TlvWrapper.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 declare class NodeId {
+    readonly id: bigint;
+    constructor(id: bigint);
+    toString(): string;
+}
+/** Tlv schema for a Node Identifier. */
+export declare const TlvNodeId: TlvWrapper<NodeId, number | bigint>;

package/dist/dts/common/SubjectId.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { NodeId } from "./NodeId.js";
+/**
+ * The meaning of a "Subject" is primarily that of describing the source for an action, using a given
+ * authentication method provided by the Secure Channel architecture.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § 6.6.2.1
+ */
+export type SubjectId = NodeId;
+/** Tlv schema for a Subject Id */
+export declare const TlvSubjectId: import("../matter.js").TlvWrapper<NodeId, number | bigint>;

package/dist/dts/common/VendorId.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 declare class VendorId {
+    readonly id: number;
+    constructor(id: number);
+}
+/** Data model for a Vendor Identifier. */
+export declare const TlvVendorId: TlvWrapper<VendorId, number>;

package/dist/{matter.d.ts → dts/matter.d.ts}

@@ -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/dts/protocol/InteractionProtocol.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 8.10
+ */
+export declare const enum StatusCode {
+    Success = 0,
+    Failure = 1,
+    InvalidSubscription = 125,
+    UnsupportedAccess = 126,
+    UnsupportedEndpoint = 127,
+    InvalidAction = 128,
+    UnsupportedCommand = 129,
+    InvalidCommand = 133,
+    UnsupportedAttribute = 134,
+    ConstraintError = 135,
+    UnsupportedWrite = 136,
+    ResourceExhausted = 137,
+    NotFound = 139,
+    UnreportableAttribute = 140,
+    InvalidDataType = 141,
+    UnsupportedRead = 143,
+    DataVersionMismatch = 146,
+    Timeout = 148,
+    UnsupportedMode = 155,
+    Busy = 156,
+    UnsupportedCluster = 195,
+    NoUpstreamSubscription = 197,
+    NeedsTimedInteraction = 198,
+    UnsupportedEvent = 199,
+    PathsExhausted = 200,
+    TimedRequestMismatch = 201,
+    FailsafeRequired = 202
+}
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.1. StatusResponseMessage
+ */
+export declare const TlvStatusResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    status: import("../tlv/TlvObject.js").FieldType<StatusCode>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.2. ReadRequestMessage
+ */
+export declare const TlvReadRequest: import("../tlv/TlvObject.js").ObjectSchema<{
+    attributes: import("../tlv/TlvObject.js").FieldType<{
+        id?: number | undefined;
+        endpointId?: number | undefined;
+        clusterId?: number | undefined;
+    }[]>;
+    isFabricFiltered: import("../tlv/TlvObject.js").FieldType<boolean>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.3. ReportDataMessage
+ */
+export declare const TlvReportData: import("../tlv/TlvObject.js").ObjectSchema<{
+    subscriptionId: import("../tlv/TlvObject.js").OptionalFieldType<number>;
+    values: import("../tlv/TlvObject.js").FieldType<{
+        value: {
+            value: import("../matter.js").TlvStream;
+            path: {
+                id: number;
+                endpointId: number;
+                clusterId: number;
+            };
+            version: number;
+        };
+    }[]>;
+    isFabricFiltered: import("../tlv/TlvObject.js").OptionalFieldType<boolean>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.4. SubscribeRequestMessage
+ */
+export declare const TlvSubscribeRequest: import("../tlv/TlvObject.js").ObjectSchema<{
+    keepSubscriptions: import("../tlv/TlvObject.js").FieldType<boolean>;
+    minIntervalFloorSeconds: import("../tlv/TlvObject.js").FieldType<number>;
+    maxIntervalCeilingSeconds: import("../tlv/TlvObject.js").FieldType<number>;
+    attributeRequests: import("../tlv/TlvObject.js").OptionalFieldType<{
+        id?: number | undefined;
+        endpointId?: number | undefined;
+        clusterId?: number | undefined;
+    }[]>;
+    eventRequests: import("../tlv/TlvObject.js").OptionalFieldType<{
+        event: number;
+        cluster: number;
+        endpoint: number;
+        node: import("../common/NodeId.js").NodeId;
+        isUrgent: boolean;
+    }[]>;
+    eventFilters: import("../tlv/TlvObject.js").OptionalFieldType<{
+        node: import("../common/NodeId.js").NodeId;
+        eventMin: number | bigint;
+    }[]>;
+    isFabricFiltered: import("../tlv/TlvObject.js").FieldType<boolean>;
+    dataVersionFilters: import("../tlv/TlvObject.js").OptionalFieldType<{
+        path: {
+            cluster: number;
+            endpoint: number;
+            node: import("../common/NodeId.js").NodeId;
+        };
+        dataVersion: number;
+    }[]>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.5. SubscribeResponseMessage
+ */
+export declare const TlvSubscribeResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    subscriptionId: import("../tlv/TlvObject.js").FieldType<number>;
+    maxIntervalCeilingSeconds: import("../tlv/TlvObject.js").FieldType<number>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.9. InvokeRequestMessage
+ */
+export declare const TlvInvokeRequest: import("../tlv/TlvObject.js").ObjectSchema<{
+    suppressResponse: import("../tlv/TlvObject.js").FieldType<boolean>;
+    timedRequest: import("../tlv/TlvObject.js").FieldType<boolean>;
+    invokes: import("../tlv/TlvObject.js").FieldType<{
+        path: {
+            id: number;
+            endpointId: number;
+            clusterId: number;
+        };
+        args: import("../matter.js").TlvStream;
+    }[]>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;
+/**
+ * @see {@link MatterCoreSpecificationV1_0}, section 10.6.10. InvokeResponseMessage
+ */
+export declare const TlvInvokeResponse: import("../tlv/TlvObject.js").ObjectSchema<{
+    suppressResponse: import("../tlv/TlvObject.js").FieldType<boolean>;
+    responses: import("../tlv/TlvObject.js").FieldType<{
+        response?: {
+            path: {
+                id: number;
+                endpointId: number;
+                clusterId: number;
+            };
+            response: import("../matter.js").TlvStream;
+        } | undefined;
+        result?: {
+            path: {
+                id: number;
+                endpointId: number;
+                clusterId: number;
+            };
+            result: {
+                code: number;
+            };
+        } | undefined;
+    }[]>;
+    interactionModelRevision: import("../tlv/TlvObject.js").FieldType<number>;
+}>;

package/dist/{schema → dts/schema}/BitmapSchema.d.ts

@@ -3,7 +3,8 @@
  * Copyright 2022 Project CHIP Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Schema } from "./Schema.js";
+import { ByteArray } from "../util/ByteArray";
+import { Schema } from "./Schema";
 declare const enum BitRangeType {
     Flag = 0,
     Number = 1,
@@ -12,7 +13,7 @@ declare const enum BitRangeType {
 type BitRange<T> = {
     type: BitRangeType;
     offset: number;
-    mask: number;
+    length: number;
 };
 declare const BitRange: <T>(type: BitRangeType, offset: number, length: number) => BitRange<T>;
 /** Defines the bit position of a boolean flag. */
@@ -37,11 +38,22 @@ export type TypeFromBitSchema<T extends BitSchema> = {
     [K in keyof T]: T[K] extends BitFieldEnum<infer E> ? E : (T[K] extends BitField ? number : boolean);
 };
 declare class BitmapSchemaInternal<T extends BitSchema> extends Schema<TypeFromBitSchema<T>, number> {
-    readonly bitSchemas: T;
+    private readonly bitSchemas;
+    private readonly masks;
     constructor(bitSchemas: T);
     encodeInternal(value: TypeFromBitSchema<T>): number;
     decodeInternal(bitmap: number): TypeFromBitSchema<T>;
 }
+declare class ByteArrayBitmapSchemaInternal<T extends BitSchema> extends Schema<TypeFromBitSchema<T>, ByteArray> {
+    private readonly bitSchemas;
+    private readonly byteArrayLength;
+    private readonly maskOffset;
+    constructor(bitSchemas: T);
+    encodeInternal(value: TypeFromBitSchema<T>): Uint8Array;
+    decodeInternal(bitmap: ByteArray): TypeFromBitSchema<T>;
+}
 /** Declares a bitmap schema by indicating the bit position and their names. */
 export declare const BitmapSchema: <T extends BitSchema>(bitSchemas: T) => BitmapSchemaInternal<T>;
+/** Declares a bitmap schema backed by a ByteArray by indicating the bit position and their names. */
+export declare const ByteArrayBitmapSchema: <T extends BitSchema>(bitSchemas: T) => ByteArrayBitmapSchemaInternal<T>;
 export {};

package/dist/{util → dts/util}/Type.d.ts

@@ -7,3 +7,4 @@
 export type Merge<A, B> = A & B extends infer AB ? {
     [K in keyof AB]: AB[K];
 } : never;
+export declare const Merge: <A, B>(a: A, b: B) => Merge<A, B>;