@ledgerhq/device-management-kit 0.0.0-20241212001220

package/lib/types/src/api/apdu/utils/ApduBuilder.d.ts

@@ -0,0 +1,113 @@
+import { Apdu } from "../../apdu/model/Apdu";
+import { type AppBuilderError } from "./AppBuilderError";
+export declare const HEADER_LENGTH = 5;
+export declare const APDU_MAX_PAYLOAD = 255;
+export declare const APDU_MAX_SIZE: number;
+export type ApduBuilderArgs = {
+    readonly ins: number;
+    readonly cla: number;
+    readonly p1: number;
+    readonly p2: number;
+};
+/**
+ * ApduBuilder is a utility class to help build APDU commands.
+ * It allows to easily add data to the data field of the APDU command
+ * and to encode this data in different formats.
+ *
+ * @example
+ * ```
+ * const apduBuilder = new ApduBuilder({ ins: 0x01, cla: 0x02, p1: 0x03, p2: 0x04 })
+ *  .add8BitUIntToData(0x05)
+ *  .add16BitUIntToData(0x0607)
+ *  .addHexaStringToData("0x0809")
+ *  .addAsciiStringToData("hello")
+ *
+ * const apdu = apduBuilder.build();
+ * const builderErrors = apduBuilder.getErrors();
+ * ```
+ */
+export declare class ApduBuilder {
+    private readonly _ins;
+    private readonly _cla;
+    private readonly _p1;
+    private readonly p2;
+    private data;
+    constructor({ ins, cla, p1, p2 }: ApduBuilderArgs);
+    /**
+     * Build a new Apdu instance with the current state of the builder
+     * @returns {Apdu} - Returns a new Apdu instance
+     */
+    build: () => Apdu;
+    /**
+     * Add a 8-bit unsigned integer to the data field (max value 0xff = 255)
+     * @param value?: number - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    add8BitUIntToData: (value: number) => ApduBuilder;
+    /**
+     * Add a 16-bit unsigned integer to the data field (max value 0xffff = 65535)
+     * @param value: number - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    add16BitUIntToData: (value: number) => ApduBuilder;
+    /**
+     * Add a 32-bit unsigned integer to the data field (max value 0xffffffff = 4294967295)
+     * @param value: number - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    add32BitUIntToData: (value: number) => ApduBuilder;
+    /**
+     * Add a Uint8Array to the data field if it has enough remaining space
+     * @param value: Uint8Array - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    addBufferToData: (value: Uint8Array) => ApduBuilder;
+    /**
+     * Add a string to the data field if it has enough remaining space
+     * and it can be formatted as a hexadecimal string
+     * @param value: string - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    addHexaStringToData: (value: string) => ApduBuilder;
+    /**
+     * Add an ascii string to the data field if it has enough remaining space
+     * @param value: string - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    addAsciiStringToData: (value: string) => ApduBuilder;
+    /**
+     * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space
+     * Length-Value encoding is a way to encode data in a binary format with the first byte
+     * being the length of the data and the following bytes being the data itself
+     * @param value: string - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    encodeInLVFromHexa: (value: string) => ApduBuilder;
+    /**
+     * Add a Length-Value encoded buffer to the data field if it has enough remaining space
+     * Length-Value encoding is a way to encode data in a binary format with the first byte
+     * being the length of the data and the following bytes being the data itself
+     * @param value: Uint8Array - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    encodeInLVFromBuffer: (value: Uint8Array) => ApduBuilder;
+    /**
+     * Add a Length-Value encoded ascii string to the data field if it has enough remaining space
+     * Length-Value encoding is a way to encode data in a binary format with the first byte
+     * being the length of the data and the following bytes being the data itself
+     * @param value: string - The value to add to the data
+     * @returns {ApduBuilder} - Returns the current instance of ApduBuilder
+     */
+    encodeInLVFromAscii: (value: string) => ApduBuilder;
+    /**
+     * Returns the remaining payload length
+     * @returns {number}
+     */
+    getAvailablePayloadLength: () => number;
+    /**
+     * Returns the current errors
+     * @returns {AppBuilderError[]} - Returns an array of errors
+     */
+    getErrors: () => AppBuilderError[];
+}
+//# sourceMappingURL=ApduBuilder.d.ts.map

package/lib/types/src/api/apdu/utils/ApduBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApduBuilder.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ApduBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAE5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,aAAa,QAAuB,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,IAAI,CAA4D;gBAE5D,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,eAAe;IAWjD;;;OAGG;IACH,KAAK,QAAO,IAAI,CACuD;IAEvE;;;;OAIG;IACH,iBAAiB,UAAW,MAAM,KAAG,WAAW,CAG9C;IAEF;;;;OAIG;IACH,kBAAkB,UAAW,MAAM,KAAG,WAAW,CAG/C;IAEF;;;;OAIG;IACH,kBAAkB,UAAW,MAAM,KAAG,WAAW,CAG/C;IAEF;;;;OAIG;IACH,eAAe,UAAW,UAAU,KAAG,WAAW,CAGhD;IAEF;;;;;OAKG;IACH,mBAAmB,UAAW,MAAM,KAAG,WAAW,CAGhD;IAEF;;;;OAIG;IACH,oBAAoB,UAAW,MAAM,KAAG,WAAW,CAGjD;IAEF;;;;;;OAMG;IACH,kBAAkB,UAAW,MAAM,KAAG,WAAW,CAG/C;IAEF;;;;;;OAMG;IACH,oBAAoB,UAAW,UAAU,KAAG,WAAW,CAGrD;IAEF;;;;;;OAMG;IACH,mBAAmB,UAAW,MAAM,KAAG,WAAW,CAGhD;IAEF;;;OAGG;IACH,yBAAyB,QAAO,MAAM,CACE;IAExC;;;OAGG;IACH,SAAS,QAAO,eAAe,EAAE,CAA0B;CAC5D"}

package/lib/types/src/api/apdu/utils/ApduBuilder.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ApduBuilder.test.d.ts.map

package/lib/types/src/api/apdu/utils/ApduBuilder.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApduBuilder.test.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ApduBuilder.test.ts"],"names":[],"mappings":""}

package/lib/types/src/api/apdu/utils/ApduParser.d.ts

@@ -0,0 +1,79 @@
+import { type ApduResponse } from "../../device-session/ApduResponse";
+import { type HexaString } from "../../utils/HexaString";
+export type TaggedField = {
+    readonly tag: number;
+    readonly value: Uint8Array;
+};
+/**
+ * ApduParser is a utility class to help parse APDU responses.
+ *
+ * It provides methods to extract fields of different types from the response.
+ *
+ * @example
+ * ```
+ * const parser = new ApduParser(apduResponse);
+ * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));
+ * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());
+ * ```
+ */
+export declare class ApduParser {
+    private parser;
+    constructor(response: ApduResponse);
+    /**
+     * Test if the length is greater than the response length
+     * @param length: number
+     * @returns {boolean} - Returns false if the length is greater than the response length
+     */
+    testMinimalLength: (length: number) => boolean;
+    /**
+     * Extract a single byte from the response
+     * @returns {number | undefined} - Returns the byte extracted from the response
+     */
+    extract8BitUInt: () => number | undefined;
+    /**
+     * Extract a 16-bit unsigned integer (Big Endian coding) from the response
+     * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response
+     */
+    extract16BitUInt: () => number | undefined;
+    /**
+     * Extract a 32-bit unsigned integer (Big Endian coding) from the response
+     * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response
+     */
+    extract32BitUInt: () => number | undefined;
+    /**
+     * Extract a field of a specified length from the response
+     * @param length: number - The length of the field to extract
+     * @returns {Uint8Array | undefined} - Returns the field extracted from the response
+     */
+    extractFieldByLength: (length: number) => Uint8Array | undefined;
+    /**
+     * Extract a field from the response that is length-value encoded
+     * @returns {Uint8Array | undefined} - Returns the field extracted from the response
+     */
+    extractFieldLVEncoded: () => Uint8Array | undefined;
+    /**
+     * Extract a field from the response that is tag-length-value encoded
+     * @returns {TaggedField | undefined} - Returns the field extracted from the response
+     */
+    extractFieldTLVEncoded: () => TaggedField | undefined;
+    /**
+     * Encode a value to a hexadecimal string
+     * @param value {Uint8Array} - The value to encode
+     * @param prefix {boolean} - Whether to add a prefix to the encoded value
+     * @returns {string} - The encoded value as a hexadecimal string
+     */
+    encodeToHexaString(value?: Uint8Array, prefix?: false): string;
+    encodeToHexaString(value?: Uint8Array, prefix?: true): HexaString;
+    /**
+     * Encode a value to an ASCII string
+     * @param value {Uint8Array} - The value to encode
+     * @returns {string} - The encoded value as an ASCII string
+     */
+    encodeToString: (value?: Uint8Array) => string;
+    /**
+     * Get the remaining length of the response
+     * @returns {number} - The remaining length of the response
+     */
+    getUnparsedRemainingLength: () => number;
+}
+//# sourceMappingURL=ApduParser.d.ts.map

package/lib/types/src/api/apdu/utils/ApduParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApduParser.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ApduParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAIxD,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,QAAQ,EAAE,YAAY;IAIlC;;;;OAIG;IACH,iBAAiB,WAAY,MAAM,KAAG,OAAO,CACL;IAExC;;;OAGG;IACH,eAAe,QAAO,MAAM,GAAG,SAAS,CAAkC;IAE1E;;;OAGG;IACH,gBAAgB,QAAO,MAAM,GAAG,SAAS,CAAmC;IAE5E;;;OAGG;IACH,gBAAgB,QAAO,MAAM,GAAG,SAAS,CAAmC;IAE5E;;;;OAIG;IACH,oBAAoB,WAAY,MAAM,KAAG,UAAU,GAAG,SAAS,CACpB;IAE3C;;;OAGG;IACH,qBAAqB,QAAO,UAAU,GAAG,SAAS,CACZ;IAEtC;;;OAGG;IACH,sBAAsB,QAAO,WAAW,GAAG,SAAS,CACb;IAEvC;;;;;OAKG;IACH,kBAAkB,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM;IAC9D,kBAAkB,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,IAAI,GAAG,UAAU;IAUjE;;;;OAIG;IACH,cAAc,WAAY,UAAU,KAAG,MAAM,CACT;IAEpC;;;OAGG;IACH,0BAA0B,QAAO,MAAM,CACI;CAC5C"}

package/lib/types/src/api/apdu/utils/ApduParser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ApduParser.test.d.ts.map

package/lib/types/src/api/apdu/utils/ApduParser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApduParser.test.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ApduParser.test.ts"],"names":[],"mappings":""}

package/lib/types/src/api/apdu/utils/AppBuilderError.d.ts

@@ -0,0 +1,28 @@
+import { type DmkError } from "../../Error";
+interface DmkAppBuilderError extends DmkError {
+    readonly message: string;
+}
+export declare class ValueOverflowError implements DmkAppBuilderError {
+    readonly _tag = "ValueOverflow";
+    readonly originalError?: Error;
+    readonly message: string;
+    constructor(value: string, max?: number | bigint);
+}
+export declare class DataOverflowError implements DmkAppBuilderError {
+    readonly _tag = "DataOverflow";
+    readonly message: string;
+    readonly originalError?: Error;
+    constructor(value: string, remaining?: number);
+}
+export declare class HexaStringEncodeError implements DmkAppBuilderError {
+    readonly _tag = "HexaString";
+    readonly message: string;
+    readonly originalError?: Error;
+    constructor(value: string);
+}
+/**
+ * Type for all possible errors that can be thrown by the AppBuilder.
+ */
+export type AppBuilderError = ValueOverflowError | DataOverflowError | HexaStringEncodeError;
+export {};
+//# sourceMappingURL=AppBuilderError.d.ts.map

package/lib/types/src/api/apdu/utils/AppBuilderError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppBuilderError.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/AppBuilderError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,UAAU,kBAAmB,SAAQ,QAAQ;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,kBAAmB,YAAW,kBAAkB;IAC3D,QAAQ,CAAC,IAAI,mBAAmB;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBACb,KAAK,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,GAAG,MAAyB;CAGnE;AAED,qBAAa,iBAAkB,YAAW,kBAAkB;IAC1D,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;gBACnB,KAAK,EAAE,MAAM,EAAE,SAAS,SAAI;CAMzC;AAED,qBAAa,qBAAsB,YAAW,kBAAkB;IAC9D,QAAQ,CAAC,IAAI,gBAAgB;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;gBACnB,KAAK,EAAE,MAAM;CAG1B;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB,kBAAkB,GAClB,iBAAiB,GACjB,qBAAqB,CAAC"}

package/lib/types/src/api/apdu/utils/ByteArrayBuilder.d.ts

@@ -0,0 +1,194 @@
+import { type AppBuilderError } from "./AppBuilderError";
+/**
+ * ByteArrayBuilder is a utility class to help build APDU payloads.
+ * It allows to easily add data to the payload of an APDU command
+ * and to encode this data in different formats.
+ *
+ * @example
+ * ```
+ * const builder = new ByteArrayBuilder(255)
+ *  .add8BitUIntToData(0x05)
+ *  .add16BitUIntToData(0x0607)
+ *  .addHexaStringToData("0x0809")
+ *  .addAsciiStringToData("hello")
+ *
+ * const payload = builder.build();
+ * const builderErrors = builder.getErrors();
+ * ```
+ */
+export declare class ByteArrayBuilder {
+    private maxPayloadSize;
+    private data;
+    private readonly errors;
+    constructor(maxPayloadSize?: number);
+    /**
+     * Build a new payload instance with the current state of the builder
+     * @returns {payload} - Returns a new payload instance
+     */
+    build: () => Uint8Array;
+    /**
+     * Try to build a new payload instance with the current state of the builder
+     * if the builder don't contain any error.
+     * @returns {payload | undefined} - Returns a new payload instance or undefined
+     */
+    tryBuild: () => Uint8Array | undefined;
+    /**
+     * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)
+     * @param value: number | bigint - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add8BitUIntToData: (value: number | bigint) => ByteArrayBuilder;
+    /**
+     * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add16BitUIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add32BitUIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add64BitUIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 128-bit unsigned integer to the payload
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add128BitUIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 256-bit unsigned integer to the payload
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add256BitUIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add16BitIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add32BitIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add64BitIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 128-bit signed integer to the payload
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add128BitIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a 256-bit signed integer to the payload
+     * @param value: number | bigint - The value to add to the data
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    add256BitIntToData: (value: number | bigint, bigEndian?: boolean) => ByteArrayBuilder;
+    /**
+     * Add a Uint8Array to the payload if it has enough remaining space
+     * @param value: Uint8Array - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    addBufferToData: (value: Uint8Array) => ByteArrayBuilder;
+    /**
+     * Add a string to the payload if it has enough remaining space
+     * and it can be formatted as a hexadecimal string
+     * @param value: string - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    addHexaStringToData: (value: string) => ByteArrayBuilder;
+    /**
+     * Add an ascii string to the data field if it has enough remaining space
+     * @param value: string - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    addAsciiStringToData: (value: string) => ByteArrayBuilder;
+    /**
+     * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space
+     * Length-Value encoding is a way to encode data in a binary format with the first byte
+     * being the length of the data and the following bytes being the data itself
+     * @param value: string - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    encodeInLVFromHexa: (value: string) => ByteArrayBuilder;
+    /**
+     * Add a Length-Value encoded buffer to the data field if it has enough remaining space
+     * Length-Value encoding is a way to encode data in a binary format with the first byte
+     * being the length of the data and the following bytes being the data itself
+     * @param value: Uint8Array - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    encodeInLVFromBuffer: (value: Uint8Array) => ByteArrayBuilder;
+    /**
+     * Add a Length-Value encoded ascii string to the data field if it has enough remaining space
+     * Length-Value encoding is a way to encode data in a binary format with the first byte
+     * being the length of the data and the following bytes being the data itself
+     * @param value: string - The value to add to the data
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    encodeInLVFromAscii: (value: string) => ByteArrayBuilder;
+    /**
+     * Returns the remaining payload length
+     * @returns {number}
+     */
+    getAvailablePayloadLength: () => number;
+    /**
+     * Returns the current errors
+     * @returns {AppBuilderError[]} - Returns an array of errors
+     */
+    getErrors: () => AppBuilderError[];
+    /**
+     * Verifies if the builder contains errors
+     * @returns {boolean} - Returns wether the builder contains errors or not
+     */
+    hasErrors: () => boolean;
+    /**
+     * Check if there is enough space to add a value to the data field
+     * @param value {string | Uint8Array | number[]} - Value to add to the data
+     * @param hasLv {boolean} - Length-Value encoding flag
+     * @returns {boolean} - Returns true if there is enough space to add the value
+     */
+    private hasEnoughLengthRemaining;
+    /**
+     * Add a number to the payload
+     * @param value: number | bigint - The value to add to the data
+     * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16
+     * @param signed: boolean - Whether the value is signed or unsigned.
+     * @param bigEndian: boolean - True to encode in big endian, false for little endian
+     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
+     */
+    private addNumberToData;
+    /**
+     * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.
+     * @param value The value to check and convert.
+     * @param sizeInBits The size of the value in bits.
+     * @param signed Whether the value is signed or unsigned.
+     * @returns The converted value, or null if the value is out of bounds.
+     */
+    private checkBoundsAndConvert;
+}
+//# sourceMappingURL=ByteArrayBuilder.d.ts.map

package/lib/types/src/api/apdu/utils/ByteArrayBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteArrayBuilder.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,mBAAmB,CAAC;AAI3B;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAgB;IAIf,OAAO,CAAC,cAAc;IAHlC,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;gBAE5B,cAAc,GAAE,MAAwB;IAM5D;;;OAGG;IACH,KAAK,QAAO,UAAU,CAAc;IAEpC;;;;OAIG;IACH,QAAQ,QAAO,UAAU,GAAG,SAAS,CAEnC;IAEF;;;;OAIG;IACH,iBAAiB,UAAW,MAAM,GAAG,MAAM,KAAG,gBAAgB,CAE5D;IAEF;;;;;OAKG;IACH,kBAAkB,UACT,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,kBAAkB,UACT,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,kBAAkB,UACT,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,mBAAmB,UACV,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,mBAAmB,UACV,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,iBAAiB,UACR,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,iBAAiB,UACR,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,iBAAiB,UACR,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,kBAAkB,UACT,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;;OAKG;IACH,kBAAkB,UACT,MAAM,GAAG,MAAM,cACX,OAAO,KACjB,gBAAgB,CAEjB;IAEF;;;;OAIG;IACH,eAAe,UAAW,UAAU,KAAG,gBAAgB,CAQrD;IAEF;;;;;OAKG;IACH,mBAAmB,UAAW,MAAM,KAAG,gBAAgB,CAQrD;IAEF;;;;OAIG;IACH,oBAAoB,UAAW,MAAM,KAAG,gBAAgB,CAItD;IAEF;;;;;;OAMG;IACH,kBAAkB,UAAW,MAAM,KAAG,gBAAgB,CAgBpD;IAEF;;;;;;OAMG;IACH,oBAAoB,UAAW,UAAU,KAAG,gBAAgB,CAS1D;IAEF;;;;;;OAMG;IACH,mBAAmB,UAAW,MAAM,KAAG,gBAAgB,CASrD;IAEF;;;OAGG;IACH,yBAAyB,QAAO,MAAM,CAEpC;IAEF;;;OAGG;IACH,SAAS,QAAO,eAAe,EAAE,CAAgB;IAEjD;;;OAGG;IACH,SAAS,QAAO,OAAO,CAA6B;IAMpD;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB,CAO9B;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IA6BvB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;CAuC9B"}

package/lib/types/src/api/apdu/utils/ByteArrayBuilder.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ByteArrayBuilder.test.d.ts.map

package/lib/types/src/api/apdu/utils/ByteArrayBuilder.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteArrayBuilder.test.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayBuilder.test.ts"],"names":[],"mappings":""}

package/lib/types/src/api/apdu/utils/ByteArrayParser.d.ts

@@ -0,0 +1,152 @@
+import { type HexaString } from "../../utils/HexaString";
+export type TaggedField = {
+    readonly tag: number;
+    readonly value: Uint8Array;
+};
+/**
+ * ByteArrayParser is a utility class to help parse a byte array.
+ *
+ * It provides methods to extract fields of different types from the buffer.
+ *
+ * @example
+ * ```
+ * const parser = new ByteArrayParser(buffer);
+ * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));
+ * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());
+ * ```
+ */
+export declare class ByteArrayParser {
+    private readonly buffer;
+    private index;
+    constructor(buffer: Uint8Array);
+    /**
+     * Test if the length is greater than the response length
+     * @param length: number
+     * @returns {boolean} - Returns false if the length is greater than the response length
+     */
+    testMinimalLength(length: number): boolean;
+    /**
+     * Extract a single byte from the response
+     * @returns {number | undefined} - Returns the byte extracted from the response
+     */
+    extract8BitUInt(): number | undefined;
+    /**
+     * Extract a 16-bit unsigned integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response
+     */
+    extract16BitUInt(bigEndian?: boolean): number | undefined;
+    /**
+     * Extract a 16-bit signed integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 16-bit signed integer extracted from the response
+     */
+    extract16BitInt(bigEndian?: boolean): number | undefined;
+    /**
+     * Extract a 32-bit unsigned integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response
+     */
+    extract32BitUInt(bigEndian?: boolean): number | undefined;
+    /**
+     * Extract a 32-bit signed integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 32-bit signed integer extracted from the response
+     */
+    extract32BitInt(bigEndian?: boolean): number | undefined;
+    /**
+     * Extract a 64-bit unsigned integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 64-bit unsigned integer extracted from the response
+     */
+    extract64BitUInt(bigEndian?: boolean): bigint | undefined;
+    /**
+     * Extract a 64-bit signed integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 64-bit signed integer extracted from the response
+     */
+    extract64BitInt(bigEndian?: boolean): bigint | undefined;
+    /**
+     * Extract a 128-bit unsigned integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 128-bit unsigned integer extracted from the response
+     */
+    extract128BitUInt(bigEndian?: boolean): bigint | undefined;
+    /**
+     * Extract a 128-bit signed integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 128-bit signed integer extracted from the response
+     */
+    extract128BitInt(bigEndian?: boolean): bigint | undefined;
+    /**
+     * Extract a 256-bit unsigned integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 256-bit unsigned integer extracted from the response
+     */
+    extract256BitUInt(bigEndian?: boolean): bigint | undefined;
+    /**
+     * Extract a 256-bit signed integer from the response
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {number | undefined} - Returns the 256-bit signed integer extracted from the response
+     */
+    extract256BitInt(bigEndian?: boolean): bigint | undefined;
+    /**
+     * Extract a field of a specified length from the response
+     * @param length: number - The length of the field to extract
+     * @returns {Uint8Array | undefined} - Returns the field extracted from the response
+     */
+    extractFieldByLength(length: number): Uint8Array | undefined;
+    /**
+     * Extract a field from the response that is length-value encoded
+     * @returns {Uint8Array | undefined} - Returns the field extracted from the response
+     */
+    extractFieldLVEncoded(): Uint8Array | undefined;
+    /**
+     * Extract a field from the response that is tag-length-value encoded
+     * @returns {TaggedField | undefined} - Returns the field extracted from the response
+     */
+    extractFieldTLVEncoded(): TaggedField | undefined;
+    /**
+     * Encode a value to a hexadecimal string
+     * @param value {Uint8Array} - The value to encode
+     * @param prefix {boolean} - Whether to add a prefix to the encoded value
+     * @returns {string} - The encoded value as a hexadecimal string
+     */
+    encodeToHexaString(value?: Uint8Array, prefix?: false): string;
+    encodeToHexaString(value?: Uint8Array, prefix?: true): HexaString;
+    /**
+     * Encode a value to an ASCII string
+     * @param value {Uint8Array} - The value to encode
+     * @returns {string} - The encoded value as an ASCII string
+     */
+    encodeToString(value?: Uint8Array): string;
+    /**
+     * Get the current index of the parser
+     * @returns {number} - The current index of the parser
+     */
+    getCurrentIndex(): number;
+    /**
+     * Reset the index of the parser to 0
+     */
+    resetIndex(): void;
+    /**
+     * Get the remaining length of the response
+     * @returns {number} - The remaining length of the response
+     */
+    getUnparsedRemainingLength(): number;
+    /**
+     * Check whether the expected length is out of range
+     * @param length: number
+     * @returns {boolean} - Returns true if the expected length is out of range
+     */
+    private outOfRange;
+    /**
+     * Extract a number from the buffer
+     * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16
+     * @param signed: boolean - True is the number can be signed and converted to two's compliment
+     * @param bigEndian: boolean - True to decode in big endian, false for little endian
+     * @returns {bigint | undefined} - Returns the number extracted from the buffer
+     */
+    private extractNumber;
+}
+//# sourceMappingURL=ByteArrayParser.d.ts.map

package/lib/types/src/api/apdu/utils/ByteArrayParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteArrayParser.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAE5E,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAGd,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,KAAK,CAAa;gBAEG,MAAM,EAAE,UAAU;IAM/C;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI1C;;;OAGG;IACH,eAAe,IAAI,MAAM,GAAG,SAAS;IAKrC;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAK/D;;;;OAIG;IACH,eAAe,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAK9D;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAK/D;;;;OAIG;IACH,eAAe,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAK9D;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAI/D;;;;OAIG;IACH,eAAe,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAI9D;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAIhE;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAI/D;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAIhE;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,GAAE,OAAc,GAAG,MAAM,GAAG,SAAS;IAI/D;;;;OAIG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAQ5D;;;OAGG;IACH,qBAAqB,IAAI,UAAU,GAAG,SAAS;IAW/C;;;OAGG;IACH,sBAAsB,IAAI,WAAW,GAAG,SAAS;IAajD;;;;;OAKG;IACH,kBAAkB,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM;IAC9D,kBAAkB,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,IAAI,GAAG,UAAU;IAUjE;;;;OAIG;IACH,cAAc,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,MAAM;IAe1C;;;OAGG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,UAAU;IAIV;;;OAGG;IACH,0BAA0B,IAAI,MAAM;IAQpC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAIlB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;CAiCtB"}

package/lib/types/src/api/apdu/utils/ByteArrayParser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ByteArrayParser.test.d.ts.map

package/lib/types/src/api/apdu/utils/ByteArrayParser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteArrayParser.test.d.ts","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayParser.test.ts"],"names":[],"mappings":""}

package/lib/types/src/api/command/Command.d.ts

@@ -0,0 +1,33 @@
+import { type Apdu } from "../apdu/model/Apdu";
+import { type CommandResult } from "../command/model/CommandResult";
+import { type DeviceModelId } from "../device/DeviceModel";
+import { type ApduResponse } from "../device-session/ApduResponse";
+/**
+ * A command that can be sent to a device.
+ *
+ * @template Response - The type of the response returned by the device.
+ * @template Args - The type of the arguments passed to the command (optional).
+ * @template ErrorCodes - The union of error codes for this command (optional).
+ */
+export interface Command<Response, Args = void, ErrorCodes = void> {
+    /**
+     * Indicates whether the command triggers a disconnection from the device when
+     * it succeeds.
+     */
+    readonly triggersDisconnection?: boolean;
+    /**
+     * Gets the APDU (Application Protocol Data Unit) for the command.
+     *
+     * @returns The APDU for the command.
+     */
+    getApdu(args?: Args): Apdu;
+    /**
+     * Parses the response received from the device.
+     *
+     * @param apduResponse - The response received from the device.
+     * @param deviceModelId - The ID of the device model (optional).
+     * @returns The parsed response.
+     */
+    parseResponse(apduResponse: ApduResponse, deviceModelId: DeviceModelId | void): CommandResult<Response, ErrorCodes>;
+}
+//# sourceMappingURL=Command.d.ts.map