@matter/types 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/tlv/TlvArray.js

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { deepCopy, serialize, UnexpectedDataError } from "#general";
+import {
+  ValidationDatatypeMismatchError,
+  ValidationError,
+  ValidationOutOfBoundsError
+} from "../common/ValidationError.js";
+import { TlvType } from "./TlvCodec.js";
+import { TlvSchema } from "./TlvSchema.js";
+class ArraySchema extends TlvSchema {
+  constructor(elementSchema, minLength = 0, maxLength = 65535) {
+    super();
+    this.elementSchema = elementSchema;
+    this.minLength = minLength;
+    this.maxLength = maxLength;
+  }
+  encodeTlvInternal(writer, value, tag, options) {
+    writer.writeTag({ type: TlvType.Array }, tag);
+    value.forEach((element) => this.elementSchema.encodeTlvInternal(writer, element, void 0, options));
+    writer.writeTag({ type: TlvType.EndOfContainer });
+  }
+  decodeTlvInternalValue(reader, typeLength) {
+    if (typeLength.type !== TlvType.Array)
+      throw new UnexpectedDataError(`Unexpected type ${typeLength.type}, expected Array (${TlvType.Array}).`);
+    const result = new Array();
+    while (true) {
+      const { tag: elementTag, typeLength: elementTypeLength } = reader.readTagType();
+      if (elementTag !== void 0) throw new UnexpectedDataError("Array element tags should be anonymous.");
+      if (elementTypeLength.type === TlvType.EndOfContainer) break;
+      result.push(this.elementSchema.decodeTlvInternalValue(reader, elementTypeLength));
+    }
+    return result;
+  }
+  injectField(value, fieldId, fieldValue, injectChecker) {
+    if (Array.isArray(value)) {
+      value.forEach(
+        (item, index) => value[index] = this.elementSchema.injectField(item, fieldId, fieldValue, injectChecker)
+      );
+    }
+    return value;
+  }
+  removeField(value, fieldId, removeChecker) {
+    if (Array.isArray(value)) {
+      value.forEach(
+        (item, index) => value[index] = this.elementSchema.removeField(item, fieldId, removeChecker)
+      );
+    }
+    return value;
+  }
+  validate(data) {
+    if (!Array.isArray(data)) throw new ValidationDatatypeMismatchError(`Expected array, got ${typeof data}.`);
+    if (data.length > this.maxLength)
+      throw new ValidationOutOfBoundsError(
+        `Array ${serialize(data)} is too long: ${data.length}, max ${this.maxLength}.`
+      );
+    if (data.length < this.minLength)
+      throw new ValidationOutOfBoundsError(
+        `Array ${serialize(data)} is too short: ${data.length}, min ${this.minLength}.`
+      );
+    data.forEach((element, index) => {
+      try {
+        this.elementSchema.validate(element);
+      } catch (e) {
+        ValidationError.accept(e);
+        e.fieldName = `[${index}]${e.fieldName !== void 0 ? `.${e.fieldName}` : ""}`;
+        throw e;
+      }
+    });
+  }
+  decodeFromChunkedArray(chunks, currentValue) {
+    if (currentValue === void 0 && chunks[0].listIndex !== void 0) {
+      throw new UnexpectedDataError(
+        `When no current value is supplied the first chunked element needs to have a list index of undefined, but received ${chunks[0].listIndex}.`
+      );
+    }
+    currentValue = currentValue !== void 0 ? deepCopy(currentValue) : [];
+    for (const { listIndex, element } of chunks) {
+      if (listIndex === void 0) {
+        currentValue = this.decodeTlv(element);
+      } else if (listIndex === null) {
+        const decodedElement = this.elementSchema.decodeTlv(element);
+        currentValue.push(decodedElement);
+      } else if (element[0].typeLength.type === TlvType.Null) {
+        currentValue.splice(listIndex, 1);
+      } else {
+        currentValue[listIndex] = this.elementSchema.decodeTlv(element);
+      }
+    }
+    return currentValue;
+  }
+  encodeAsChunkedArray(value) {
+    const result = [];
+    result.push({ listIndex: void 0, element: this.encodeTlv([]) });
+    value.forEach((element) => {
+      const elementStream = this.elementSchema.encodeTlv(element);
+      result.push({ listIndex: null, element: elementStream });
+    });
+    return result;
+  }
+}
+const TlvArray = (elementSchema, { minLength, maxLength, length } = {}) => new ArraySchema(elementSchema, length ?? minLength, length ?? maxLength);
+export {
+  ArraySchema,
+  TlvArray
+};
+//# sourceMappingURL=TlvArray.js.map

package/dist/esm/tlv/TlvArray.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/TlvArray.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/tlv/TlvBoolean.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvTag, TlvTypeLength } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+/**
+ * Schema to encode a boolean in TLV.
+ *
+ * @see {@link MatterSpecification.v10.Core} § A.11.3
+ */
+export declare class BooleanSchema extends TlvSchema<boolean> {
+    encodeTlvInternal(writer: TlvWriter, value: boolean, tag?: TlvTag): void;
+    decodeTlvInternalValue(_reader: TlvReader, typeLength: TlvTypeLength): boolean;
+    validate(value: boolean): void;
+}
+/** Boolean TLV schema. */
+export declare const TlvBoolean: BooleanSchema;
+//# sourceMappingURL=TlvBoolean.d.ts.map

package/dist/esm/tlv/TlvBoolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TlvBoolean.d.ts","sourceRoot":"","sources":["../../../src/tlv/TlvBoolean.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,MAAM,EAAW,aAAa,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,SAAS,CAAC,OAAO,CAAC;IACxC,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAIxE,sBAAsB,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa;IAKpE,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;CAI1C;AAED,0BAA0B;AAC1B,eAAO,MAAM,UAAU,eAAsB,CAAC"}

package/dist/esm/tlv/TlvBoolean.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { UnexpectedDataError } from "#general";
+import { ValidationDatatypeMismatchError } from "../common/ValidationError.js";
+import { TlvType } from "./TlvCodec.js";
+import { TlvSchema } from "./TlvSchema.js";
+class BooleanSchema extends TlvSchema {
+  encodeTlvInternal(writer, value, tag) {
+    writer.writeTag({ type: TlvType.Boolean, value }, tag);
+  }
+  decodeTlvInternalValue(_reader, typeLength) {
+    if (typeLength.type !== TlvType.Boolean) throw new UnexpectedDataError(`Unexpected type ${typeLength.type}.`);
+    return typeLength.value;
+  }
+  validate(value) {
+    if (typeof value !== "boolean")
+      throw new ValidationDatatypeMismatchError(`Expected boolean, got ${typeof value}.`);
+  }
+}
+const TlvBoolean = new BooleanSchema();
+export {
+  BooleanSchema,
+  TlvBoolean
+};
+//# sourceMappingURL=TlvBoolean.js.map

package/dist/esm/tlv/TlvBoolean.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/TlvBoolean.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,2BAA2B;AACpC,SAAS,uCAAuC;AAChD,SAAiB,eAA8B;AAC/C,SAAoB,iBAA4B;AAOzC,MAAM,sBAAsB,UAAmB;AAAA,EACzC,kBAAkB,QAAmB,OAAgB,KAAoB;AAC9E,WAAO,SAAS,EAAE,MAAM,QAAQ,SAAS,MAAM,GAAG,GAAG;AAAA,EACzD;AAAA,EAES,uBAAuB,SAAoB,YAA2B;AAC3E,QAAI,WAAW,SAAS,QAAQ,QAAS,OAAM,IAAI,oBAAoB,mBAAmB,WAAW,IAAI,GAAG;AAC5G,WAAO,WAAW;AAAA,EACtB;AAAA,EAES,SAAS,OAAsB;AACpC,QAAI,OAAO,UAAU;AACjB,YAAM,IAAI,gCAAgC,yBAAyB,OAAO,KAAK,GAAG;AAAA,EAC1F;AACJ;AAGO,MAAM,aAAa,IAAI,cAAc;",
+  "names": []
+}

package/dist/esm/tlv/TlvCodec.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DataReader, DataWriter, Endian } from "#general";
+/**
+ * TLV element types.
+ *
+ * @see {@link MatterSpecification.v10.Core} § A.7.1
+ */
+export declare enum TlvType {
+    SignedInt = 0,
+    UnsignedInt = 4,
+    Boolean = 8,
+    Float = 10,
+    Utf8String = 12,
+    ByteString = 16,
+    Null = 20,
+    Structure = 21,
+    Array = 22,
+    List = 23,
+    EndOfContainer = 24
+}
+/** Byte length of the encoded value or length. */
+export declare enum TlvLength {
+    OneByte = 0,
+    TwoBytes = 1,
+    FourBytes = 2,
+    EightBytes = 3
+}
+/** Type and length or value, when applicable. */
+export type TlvTypeLength = {
+    type: TlvType.SignedInt;
+    length: TlvLength;
+} | {
+    type: TlvType.UnsignedInt;
+    length: TlvLength;
+} | {
+    type: TlvType.Boolean;
+    value: boolean;
+} | {
+    type: TlvType.Float;
+    length: TlvLength.FourBytes | TlvLength.EightBytes;
+} | {
+    type: TlvType.Utf8String;
+    length: TlvLength;
+} | {
+    type: TlvType.ByteString;
+    length: TlvLength;
+} | {
+    type: TlvType.Null;
+} | {
+    type: TlvType.Structure;
+} | {
+    type: TlvType.Array;
+} | {
+    type: TlvType.List;
+} | {
+    type: TlvType.EndOfContainer;
+};
+/** Converts {@link TlvType} to the js primitive type.  */
+export type TlvToPrimitive = {
+    [TlvType.SignedInt]: bigint | number;
+    [TlvType.UnsignedInt]: bigint | number;
+    [TlvType.Boolean]: never;
+    [TlvType.Float]: number;
+    [TlvType.Utf8String]: string;
+    [TlvType.ByteString]: Uint8Array;
+    [TlvType.Null]: null;
+    [TlvType.Structure]: never;
+    [TlvType.Array]: never;
+    [TlvType.List]: never;
+    [TlvType.EndOfContainer]: never;
+};
+/** {@link MatterSpecification.v10.Core} § A.2 */
+export type TlvTag = {
+    profile?: number;
+    id?: number;
+};
+export declare class TlvCodec {
+    static getUIntTlvLength(value: number | bigint): TlvLength;
+    static getIntTlvLength(value: number | bigint): TlvLength;
+    /** @see {@link MatterSpecification.v10.Core} § A.7 */
+    static readTagType(reader: DataReader<Endian.Little>): {
+        tag?: TlvTag;
+        typeLength: TlvTypeLength;
+    };
+    private static readTag;
+    private static parseTypeLength;
+    static readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T["type"]]>(reader: DataReader<Endian.Little>, typeLength: T): V;
+    /** @see {@link MatterSpecification.v10.Core} § A.7 & A.8 */
+    static writeTag(writer: DataWriter<Endian.Little>, typeLengthValue: TlvTypeLength, tag?: TlvTag): void;
+    static getTagByteLength(tag?: TlvTag): 1 | 2 | 3 | 5 | 7 | 9;
+    static writePrimitive<T extends TlvTypeLength>(writer: DataWriter<Endian.Little>, typeLength: T, value: TlvToPrimitive[T["type"]]): void;
+    static getPrimitiveByteLength<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T["type"]]): number;
+    private static writeUInt;
+    private static getUIntByteLength;
+}
+//# sourceMappingURL=TlvCodec.d.ts.map

package/dist/esm/tlv/TlvCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TlvCodec.d.ts","sourceRoot":"","sources":["../../../src/tlv/TlvCodec.ts"],"names":[],"mappings":"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"}

package/dist/esm/tlv/TlvCodec.js

@@ -0,0 +1,397 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  Bytes,
+  INT16_MAX,
+  INT16_MIN,
+  INT32_MAX,
+  INT32_MIN,
+  INT8_MAX,
+  INT8_MIN,
+  NotImplementedError,
+  UINT16_MAX,
+  UINT32_MAX,
+  UINT8_MAX,
+  UnexpectedDataError
+} from "#general";
+import { BitField, BitFieldEnum, BitmapSchema } from "../schema/BitmapSchema.js";
+var TlvType = /* @__PURE__ */ ((TlvType2) => {
+  TlvType2[TlvType2["SignedInt"] = 0] = "SignedInt";
+  TlvType2[TlvType2["UnsignedInt"] = 4] = "UnsignedInt";
+  TlvType2[TlvType2["Boolean"] = 8] = "Boolean";
+  TlvType2[TlvType2["Float"] = 10] = "Float";
+  TlvType2[TlvType2["Utf8String"] = 12] = "Utf8String";
+  TlvType2[TlvType2["ByteString"] = 16] = "ByteString";
+  TlvType2[TlvType2["Null"] = 20] = "Null";
+  TlvType2[TlvType2["Structure"] = 21] = "Structure";
+  TlvType2[TlvType2["Array"] = 22] = "Array";
+  TlvType2[TlvType2["List"] = 23] = "List";
+  TlvType2[TlvType2["EndOfContainer"] = 24] = "EndOfContainer";
+  return TlvType2;
+})(TlvType || {});
+var TlvLength = /* @__PURE__ */ ((TlvLength2) => {
+  TlvLength2[TlvLength2["OneByte"] = 0] = "OneByte";
+  TlvLength2[TlvLength2["TwoBytes"] = 1] = "TwoBytes";
+  TlvLength2[TlvLength2["FourBytes"] = 2] = "FourBytes";
+  TlvLength2[TlvLength2["EightBytes"] = 3] = "EightBytes";
+  return TlvLength2;
+})(TlvLength || {});
+var TagControl = /* @__PURE__ */ ((TagControl2) => {
+  TagControl2[TagControl2["Anonymous"] = 0] = "Anonymous";
+  TagControl2[TagControl2["ContextSpecific"] = 1] = "ContextSpecific";
+  TagControl2[TagControl2["CommonProfile16"] = 2] = "CommonProfile16";
+  TagControl2[TagControl2["CommonProfile32"] = 3] = "CommonProfile32";
+  TagControl2[TagControl2["ImplicitProfile16"] = 4] = "ImplicitProfile16";
+  TagControl2[TagControl2["ImplicitProfile32"] = 5] = "ImplicitProfile32";
+  TagControl2[TagControl2["FullyQualified48"] = 6] = "FullyQualified48";
+  TagControl2[TagControl2["FullyQualified64"] = 7] = "FullyQualified64";
+  return TagControl2;
+})(TagControl || {});
+const ControlByteSchema = BitmapSchema({
+  typeLength: BitField(0, 5),
+  tagControl: BitFieldEnum(5, 3)
+});
+const MATTER_COMMON_PROFILE = 0;
+class TlvCodec {
+  static getUIntTlvLength(value) {
+    if (value <= UINT8_MAX) {
+      return 0 /* OneByte */;
+    } else if (value <= UINT16_MAX) {
+      return 1 /* TwoBytes */;
+    } else if (value <= UINT32_MAX) {
+      return 2 /* FourBytes */;
+    } else {
+      return 3 /* EightBytes */;
+    }
+  }
+  static getIntTlvLength(value) {
+    if (value > 0) {
+      if (value <= INT8_MAX) {
+        return 0 /* OneByte */;
+      } else if (value <= INT16_MAX) {
+        return 1 /* TwoBytes */;
+      } else if (value <= INT32_MAX) {
+        return 2 /* FourBytes */;
+      } else {
+        return 3 /* EightBytes */;
+      }
+    } else {
+      if (value >= INT8_MIN) {
+        return 0 /* OneByte */;
+      } else if (value >= INT16_MIN) {
+        return 1 /* TwoBytes */;
+      } else if (value >= INT32_MIN) {
+        return 2 /* FourBytes */;
+      } else {
+        return 3 /* EightBytes */;
+      }
+    }
+  }
+  /** @see {@link MatterSpecification.v10.Core} § A.7 */
+  static readTagType(reader) {
+    const { tagControl, typeLength } = ControlByteSchema.decode(reader.readUInt8());
+    return { tag: this.readTag(reader, tagControl), typeLength: this.parseTypeLength(typeLength) };
+  }
+  static readTag(reader, tagControl) {
+    switch (tagControl) {
+      case 0 /* Anonymous */:
+        return void 0;
+      case 1 /* ContextSpecific */:
+        return { id: reader.readUInt8() };
+      case 2 /* CommonProfile16 */:
+        return { profile: MATTER_COMMON_PROFILE, id: reader.readUInt16() };
+      case 3 /* CommonProfile32 */:
+        return { profile: MATTER_COMMON_PROFILE, id: reader.readUInt32() };
+      case 4 /* ImplicitProfile16 */:
+      case 5 /* ImplicitProfile32 */:
+        throw new NotImplementedError(`Unsupported implicit profile ${tagControl}`);
+      case 6 /* FullyQualified48 */:
+        return { profile: reader.readUInt32(), id: reader.readUInt16() };
+      default:
+        throw new NotImplementedError(`Unexpected tagControl ${tagControl}`);
+    }
+  }
+  static parseTypeLength(typeLength) {
+    const length = typeLength & 3;
+    const type = typeLength & 252;
+    switch (type) {
+      case 12 /* Utf8String */:
+      case 16 /* ByteString */:
+      case 0 /* SignedInt */:
+      case 4 /* UnsignedInt */:
+        return { type, length };
+      case 8 /* Boolean */:
+        switch (length) {
+          case 0 /* OneByte */:
+            return { type, value: false };
+          case 1 /* TwoBytes */:
+            return { type, value: true };
+          case 2 /* FourBytes */:
+            return { type: 10 /* Float */, length };
+          case 3 /* EightBytes */:
+            return { type: 10 /* Float */, length };
+          default:
+            throw new UnexpectedDataError(`Unexpected Boolean length ${length}`);
+        }
+      default:
+        return { type: typeLength };
+    }
+  }
+  static readPrimitive(reader, typeLength) {
+    switch (typeLength.type) {
+      case 0 /* SignedInt */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 0 /* OneByte */:
+            return reader.readInt8();
+          case 1 /* TwoBytes */:
+            return reader.readInt16();
+          case 2 /* FourBytes */:
+            return reader.readInt32();
+          case 3 /* EightBytes */:
+            return reader.readInt64();
+          default:
+            throw new UnexpectedDataError(`Unexpected SignedInt length ${length}`);
+        }
+      }
+      case 4 /* UnsignedInt */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 0 /* OneByte */:
+            return reader.readUInt8();
+          case 1 /* TwoBytes */:
+            return reader.readUInt16();
+          case 2 /* FourBytes */:
+            return reader.readUInt32();
+          case 3 /* EightBytes */:
+            return reader.readUInt64();
+          default:
+            throw new UnexpectedDataError(`Unexpected UnsignedInt length ${length}`);
+        }
+      }
+      case 10 /* Float */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 2 /* FourBytes */:
+            return reader.readFloat();
+          case 3 /* EightBytes */:
+            return reader.readDouble();
+          default:
+            throw new UnexpectedDataError(`Unexpected Float length ${length}`);
+        }
+      }
+      case 12 /* Utf8String */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 0 /* OneByte */:
+            return reader.readUtf8String(reader.readUInt8());
+          case 1 /* TwoBytes */:
+            return reader.readUtf8String(reader.readUInt16());
+          case 2 /* FourBytes */:
+            return reader.readUtf8String(reader.readUInt32());
+          case 3 /* EightBytes */:
+            return reader.readUtf8String(Number(reader.readUInt64()));
+          default:
+            throw new UnexpectedDataError(`Unexpected Utf8String length ${length}`);
+        }
+      }
+      case 16 /* ByteString */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 0 /* OneByte */:
+            return reader.readByteArray(reader.readUInt8());
+          case 1 /* TwoBytes */:
+            return reader.readByteArray(reader.readUInt16());
+          case 2 /* FourBytes */:
+            return reader.readByteArray(reader.readUInt32());
+          case 3 /* EightBytes */:
+            return reader.readByteArray(Number(reader.readUInt64()));
+          default:
+            throw new UnexpectedDataError(`Unexpected ByteString length ${length}`);
+        }
+      }
+      case 8 /* Boolean */:
+        return typeLength.value;
+      case 20 /* Null */:
+        return null;
+      default:
+        throw new UnexpectedDataError(`Unexpected TLV type ${typeLength.type}`);
+    }
+  }
+  /** @see {@link MatterSpecification.v10.Core} § A.7 & A.8 */
+  static writeTag(writer, typeLengthValue, tag) {
+    const { profile, id } = tag ?? {};
+    let typeLength;
+    switch (typeLengthValue.type) {
+      case 12 /* Utf8String */:
+      case 16 /* ByteString */:
+      case 0 /* SignedInt */:
+      case 4 /* UnsignedInt */:
+      case 10 /* Float */:
+        typeLength = typeLengthValue.type | typeLengthValue.length;
+        break;
+      case 8 /* Boolean */:
+        typeLength = typeLengthValue.type + (typeLengthValue.value ? 1 : 0);
+        break;
+      default:
+        typeLength = typeLengthValue.type;
+    }
+    if (profile === void 0 && id === void 0) {
+      writer.writeUInt8(ControlByteSchema.encode({ tagControl: 0 /* Anonymous */, typeLength }));
+    } else if (profile === void 0) {
+      if (id === void 0)
+        throw new UnexpectedDataError("Invalid TLV tag: id should be defined for a context specific tag.");
+      writer.writeUInt8(ControlByteSchema.encode({ tagControl: 1 /* ContextSpecific */, typeLength }));
+      writer.writeUInt8(id);
+    } else if (profile === MATTER_COMMON_PROFILE) {
+      if (id === void 0)
+        throw new UnexpectedDataError("Invalid TLV tag: id should be defined for a datatype profile.");
+      if ((id & 4294901760) === 0) {
+        writer.writeUInt8(ControlByteSchema.encode({ tagControl: 2 /* CommonProfile16 */, typeLength }));
+        writer.writeUInt16(id);
+      } else {
+        writer.writeUInt8(ControlByteSchema.encode({ tagControl: 3 /* CommonProfile32 */, typeLength }));
+        writer.writeUInt32(id);
+      }
+    } else {
+      if (id === void 0)
+        throw new UnexpectedDataError("Invalid TLV tag: id should be defined for a custom profile.");
+      if ((id & 4294901760) === 0) {
+        writer.writeUInt8(ControlByteSchema.encode({ tagControl: 6 /* FullyQualified48 */, typeLength }));
+        writer.writeUInt32(profile);
+        writer.writeUInt16(id);
+      } else {
+        writer.writeUInt8(ControlByteSchema.encode({ tagControl: 7 /* FullyQualified64 */, typeLength }));
+        writer.writeUInt32(profile);
+        writer.writeUInt32(id);
+      }
+    }
+  }
+  static getTagByteLength(tag) {
+    const { profile, id } = tag ?? {};
+    if (profile === void 0 && id === void 0) {
+      return 1;
+    } else if (profile === void 0) {
+      if (id === void 0)
+        throw new UnexpectedDataError("Invalid TLV tag: id should be defined for a context specific tag.");
+      return 2;
+    } else if (profile === MATTER_COMMON_PROFILE) {
+      if (id === void 0)
+        throw new UnexpectedDataError("Invalid TLV tag: id should be defined for a datatype profile.");
+      if ((id & 4294901760) === 0) {
+        return 3;
+      } else {
+        return 5;
+      }
+    } else {
+      if (id === void 0)
+        throw new UnexpectedDataError("Invalid TLV tag: id should be defined for a custom profile.");
+      if ((id & 4294901760) === 0) {
+        return 7;
+      } else {
+        return 9;
+      }
+    }
+  }
+  static writePrimitive(writer, typeLength, value) {
+    switch (typeLength.type) {
+      case 0 /* SignedInt */:
+        return this.writeUInt(writer, typeLength.length, value);
+      case 4 /* UnsignedInt */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 0 /* OneByte */:
+            return writer.writeUInt8(value);
+          case 1 /* TwoBytes */:
+            return writer.writeUInt16(value);
+          case 2 /* FourBytes */:
+            return writer.writeUInt32(value);
+          case 3 /* EightBytes */:
+            return writer.writeUInt64(value);
+          default:
+            throw new UnexpectedDataError(`Unexpected UnsignedInt length ${length}`);
+        }
+      }
+      case 10 /* Float */: {
+        const length = typeLength.length;
+        switch (length) {
+          case 2 /* FourBytes */:
+            return writer.writeFloat(value);
+          case 3 /* EightBytes */:
+            return writer.writeDouble(value);
+          default:
+            throw new UnexpectedDataError(`Unexpected Float length ${length}`);
+        }
+      }
+      case 12 /* Utf8String */: {
+        const string = value;
+        const stringData = Bytes.fromString(string);
+        this.writeUInt(writer, typeLength.length, stringData.length);
+        return writer.writeByteArray(stringData);
+      }
+      case 16 /* ByteString */: {
+        const byteArray = value;
+        this.writeUInt(writer, typeLength.length, byteArray.length);
+        return writer.writeByteArray(byteArray);
+      }
+      case 8 /* Boolean */:
+        return;
+      default:
+        throw new UnexpectedDataError(`Unexpected TLV type ${typeLength.type}`);
+    }
+  }
+  static getPrimitiveByteLength(typeLength, value) {
+    switch (typeLength.type) {
+      case 0 /* SignedInt */:
+      case 4 /* UnsignedInt */:
+      case 10 /* Float */:
+        return this.getUIntByteLength(typeLength.length);
+      case 12 /* Utf8String */: {
+        const string = value;
+        const stringData = Bytes.fromString(string);
+        return this.getUIntByteLength(typeLength.length) + stringData.length;
+      }
+      case 16 /* ByteString */: {
+        const byteArray = value;
+        return this.getUIntByteLength(typeLength.length) + byteArray.length;
+      }
+      case 8 /* Boolean */:
+        return 0;
+      default:
+        throw new UnexpectedDataError(`Unexpected TLV type ${typeLength.type}`);
+    }
+  }
+  static writeUInt(writer, length, value) {
+    switch (length) {
+      case 0 /* OneByte */:
+        return writer.writeInt8(value);
+      case 1 /* TwoBytes */:
+        return writer.writeInt16(value);
+      case 2 /* FourBytes */:
+        return writer.writeInt32(value);
+      case 3 /* EightBytes */:
+        return writer.writeInt64(value);
+    }
+  }
+  static getUIntByteLength(length) {
+    switch (length) {
+      case 0 /* OneByte */:
+        return 1;
+      case 1 /* TwoBytes */:
+        return 2;
+      case 2 /* FourBytes */:
+        return 4;
+      case 3 /* EightBytes */:
+        return 8;
+    }
+  }
+}
+export {
+  TlvCodec,
+  TlvLength,
+  TlvType
+};
+//# sourceMappingURL=TlvCodec.js.map