@cmts-dev/carmentis-sdk-core 1.2.2 → 1.2.4

package/dist/crypto/encryption/symmetric-encryption/encryption-interface.d.ts

@@ -0,0 +1,179 @@
+export interface SymmetricEncryptionKeyScheme {
+    getSymmetricEncryptionSchemeId(): number;
+    getSupportedKeyLengths(): number[];
+    getDefaultKeyLength(): number;
+}
+/**
+ * Represents a symmetric encryption key capable of performing encryption and decryption
+ * operations, as well as providing the associated encryption algorithm identifier and raw key.
+ */
+export interface SymmetricEncryptionKey {
+    /**
+     * Retrieves the unique identifier of the encryption algorithm being used.
+     *
+     * @return {number} The unique algorithm identifier as a numeric value.
+     */
+    getSymmetricEncryptionSchemeId(): number;
+    /**
+     * Encrypts the given plaintext using a predefined encryption algorithm.
+     *
+     * @param {Uint8Array} plaintext - The plaintext data to be encrypted.
+     * @return {Promise<Uint8Array>} The encrypted data as a Uint8Array.
+     */
+    encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypts the given ciphertext and returns the resulting plaintext.
+     *
+     * @param {Uint8Array} ciphertext - The encrypted data to be decrypted.
+     * @return {Promise<Uint8Array>} The decrypted plaintext as a Uint8Array.
+     */
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Retrieves the raw secret key as a Uint8Array.
+     *
+     * @return {Uint8Array} The raw secret key in binary format.
+     */
+    getRawSecretKey(): Uint8Array;
+}
+/**
+ * Enumeration representing identifiers for symmetric encryption algorithms.
+ *
+ * This enum is used to specify the symmetric encryption algorithm to be utilized,
+ * enabling cryptographic operations such as encryption and decryption with specific
+ * algorithmic requirements. It currently supports the following algorithm:
+ *
+ * - AES-256-GCM: Advanced Encryption Standard with a 256-bit key in Galois/Counter Mode.
+ *
+ * The identifiers in this enum can be utilized to indicate the intended algorithm
+ * within encryption workflows or cryptographic libraries requiring algorithm specification.
+ */
+export declare enum SymmetricEncryptionSchemeId {
+    AES_256_GCM = 0
+}
+export declare class AES256GCMSymmetricEncryptionScheme implements SymmetricEncryptionKeyScheme {
+    private static KEY_LENGTH_IN_BYTES;
+    getSymmetricEncryptionSchemeId(): number;
+    getSupportedKeyLengths(): number[];
+    getDefaultKeyLength(): number;
+}
+/**
+ * This class provides methods for creating, managing, and utilizing a symmetric encryption key specifically
+ * designed for AES-256-GCM encryption. It implements the `SymmetricEncryptionKey` interface, enabling compatibility
+ * with other cryptographic operations requiring symmetric key encryption.
+ *
+ * AES-256-GCM (Advanced Encryption Standard with 256-bit keys in Galois/Counter Mode) ensures high-level cryptographic
+ * security with authenticated encryption, combining data confidentiality with integrity protection.
+ */
+export declare class AES256GCMSymmetricEncryptionKey implements SymmetricEncryptionKey {
+    private key;
+    constructor(key: Uint8Array);
+    /**
+     * Generates a new AES-256-GCM symmetric encryption key.
+     *
+     * @return {AES256GCMSymmetricEncryptionKey} An instance of AES256GCMSymmetricEncryptionKey containing a randomly generated 256-bit encryption key.
+     */
+    static generate(): Promise<AES256GCMSymmetricEncryptionKey>;
+    /**
+     * Creates an instance of AES256GCMSymmetricEncryptionKey from the given byte array.
+     *
+     * @param {Uint8Array} keyBytes - The byte array representing the encryption key.
+     * @return {AES256GCMSymmetricEncryptionKey} A new instance of AES256GCMSymmetricEncryptionKey initialized with the provided key bytes.
+     */
+    static createFromBytes(keyBytes: Uint8Array): AES256GCMSymmetricEncryptionKey;
+    /**
+     * Retrieves the raw secret key as a Uint8Array.
+     * This method provides access to the underlying key data stored in this instance.
+     *
+     * @return {Uint8Array} The raw secret key.
+     */
+    getRawSecretKey(): Uint8Array;
+    /**
+     * Retrieves the identifier of the encryption algorithm being used.
+     *
+     * @return {number} The numerical ID corresponding to the encryption algorithm.
+     */
+    getSymmetricEncryptionSchemeId(): number;
+    /**
+     * Encrypts the given plaintext using AES-GCM encryption.
+     * A random initialization vector (IV) is generated for each encryption operation.
+     * The result is a concatenation of the IV and the encrypted ciphertext.
+     *
+     * @param {Uint8Array} plaintext - The plaintext data to be encrypted.
+     * @return {Uint8Array} A Uint8Array containing the IV followed by the encrypted ciphertext.
+     */
+    encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypts the provided ciphertext using the GCM block cipher mode with the instance's key.
+     *
+     * @param {Uint8Array} ciphertext - The encrypted data to be decrypted. The first 12 bytes are assumed to be the initialization vector (IV), and the rest is the encrypted content.
+     * @return {Uint8Array} The decrypted plaintext as a Uint8Array.
+     */
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * A class that extends the functionality of a symmetric encryption key.
+ * This class enables encryption and decryption of strings,
+ * while delegating the underlying encryption and decryption operations to a wrapped key.
+ */
+export declare class ExtendedSymmetricEncryptionKey implements SymmetricEncryptionKey {
+    private wrappedKey;
+    constructor(wrappedKey: SymmetricEncryptionKey);
+    /**
+     * Encrypts a given plaintext string and returns the encrypted data as a Base64-encoded string.
+     *
+     * @param {string} plaintext - The plain text string to be encrypted.
+     * @return {string} The Base64-encoded string representation of the encrypted data.
+     */
+    encryptString(plaintext: string): Promise<string>;
+    /**
+     * Decrypts a given string that is encoded in Base64 format.
+     *
+     * @param ciphertext The Base64 encoded string to be decrypted.
+     * @return The decrypted string.
+     */
+    decryptString(ciphertext: string): Promise<string>;
+    /**
+     * Retrieves the identifier of the encryption algorithm used.
+     *
+     * @return {number} The identifier of the encryption algorithm.
+     */
+    getSymmetricEncryptionSchemeId(): number;
+    /**
+     * Encrypts the given plaintext using the wrapped key.
+     *
+     * @param {Uint8Array} plaintext - The data to be encrypted.
+     * @return {Uint8Array} The encrypted ciphertext as a Uint8Array.
+     */
+    encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypts the provided ciphertext using the wrapped key.
+     *
+     * @param {Uint8Array} ciphertext - The ciphertext to be decrypted.
+     * @return {Uint8Array} The decrypted plaintext as a Uint8Array.
+     */
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Retrieves the raw secret key from the wrapped key.
+     *
+     * @return {Uint8Array} The raw secret key as a Uint8Array.
+     */
+    getRawSecretKey(): Uint8Array;
+}
+export interface DecapsulationKey {
+    decapsulate(ct: string): SymmetricEncryptionKey;
+    getEncapsulationKey(): EncapsulationKey;
+}
+export interface EncapsulationKey {
+    encapsulate(): {
+        key: SymmetricEncryptionKey;
+        ct: string;
+    };
+}
+export interface EncapsulationKeyEncoder<T> {
+    encode(key: T): string;
+    decode(key: string): T;
+}
+export declare enum KeyExchangeSchemeId {
+    ML_KEM = 0
+}
+//# sourceMappingURL=encryption-interface.d.ts.map

package/dist/crypto/encryption/symmetric-encryption/encryption-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption-interface.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/symmetric-encryption/encryption-interface.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,4BAA4B;IACzC,8BAA8B,IAAI,MAAM,CAAC;IACzC,sBAAsB,IAAI,MAAM,EAAE,CAAC;IACnC,mBAAmB,IAAI,MAAM,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACnC;;;;OAIG;IACH,8BAA8B,IAAI,MAAM,CAAC;IAEzC;;;;;OAKG;IACH,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD;;;;;OAKG;IACH,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACrD;;;;OAIG;IACH,eAAe,IAAI,UAAU,CAAC;CACjC;AAGD;;;;;;;;;;;GAWG;AACH,oBAAY,2BAA2B;IACnC,WAAW,IAAA;CACd;AAED,qBAAa,kCAAmC,YAAW,4BAA4B;IACnF,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAM;IAExC,8BAA8B,IAAI,MAAM;IAIxC,sBAAsB,IAAI,MAAM,EAAE;IAIlC,mBAAmB,IAAI,MAAM;CAGhC;AAED;;;;;;;GAOG;AACH,qBAAa,+BAAgC,YAAW,sBAAsB;IAC9D,OAAO,CAAC,GAAG;gBAAH,GAAG,EAAE,UAAU;IAEnC;;;;OAIG;WACiB,QAAQ,IAAI,OAAO,CAAC,+BAA+B,CAAC;IAMxE;;;;;OAKG;WACW,eAAe,CAAC,QAAQ,EAAE,UAAU,GAAG,+BAA+B;IAIpF;;;;;OAKG;IACH,eAAe,IAAI,UAAU;IAI7B;;;;OAIG;IACH,8BAA8B,IAAI,MAAM;IAIxC;;;;;;;OAOG;IACG,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAWzD;;;;;OAKG;IACG,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;CAc7D;AAGD;;;;GAIG;AACH,qBAAa,8BAA+B,YAAW,sBAAsB;IAC7D,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,sBAAsB;IAGtD;;;;;OAKG;IACU,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO9D;;;;;OAKG;IACU,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO/D;;;;OAIG;IACH,8BAA8B,IAAI,MAAM;IAIxC;;;;;OAKG;IACG,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAIzD;;;;;OAKG;IACG,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAI1D;;;;OAIG;IACH,eAAe,IAAI,UAAU;CAGhC;AAED,MAAM,WAAW,gBAAgB;IAC7B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,CAAC;IAChD,mBAAmB,IAAI,gBAAgB,CAAC;CAC3C;AAED,MAAM,WAAW,gBAAgB;IAC7B,WAAW,IAAI;QAAE,GAAG,EAAE,sBAAsB,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACtC,MAAM,CAAE,GAAG,EAAE,CAAC,GAAI,MAAM,CAAC;IACzB,MAAM,CAAE,GAAG,EAAE,MAAM,GAAI,CAAC,CAAC;CAC5B;AAED,oBAAY,mBAAmB;IAC3B,MAAM,IAAA;CACT"}

package/dist/crypto/encryption/symmetric-encryption/generic-symmetric-key-encoder.d.ts

@@ -0,0 +1,25 @@
+import { SymmetricEncryptionKey } from './encryption-interface';
+/**
+ * A class responsible for encoding and decoding symmetric encryption keys.
+ * It provides functionalities to serialize and deserialize symmetric encryption keys to and from a Uint8Array.
+ */
+export declare class GenericSymmetricKeyEncoder {
+    /**
+     * Encodes a given symmetric encryption key as a Uint8Array.
+     *
+     * @param {SymmetricEncryptionKey} key - The symmetric encryption key to encode.
+     *                                        It must provide methods to retrieve the encryption scheme ID
+     *                                        and the raw secret key as a hexadecimal string.
+     * @return {Uint8Array} The encoded representation of the symmetric encryption key in Uint8Array format.
+     */
+    encodeAsUint8Array(key: SymmetricEncryptionKey): Uint8Array;
+    /**
+     * Decodes a Uint8Array into a SymmetricEncryptionKey object.
+     *
+     * @param {Uint8Array} key - The Uint8Array containing the encoded symmetric encryption key.
+     * @return {SymmetricEncryptionKey} Returns the decoded symmetric encryption key object.
+     * @throws {Error} Throws an error if the input format is invalid or does not meet the expected structure.
+     */
+    decodeFromUint8Array(key: Uint8Array): SymmetricEncryptionKey;
+}
+//# sourceMappingURL=generic-symmetric-key-encoder.d.ts.map

package/dist/crypto/encryption/symmetric-encryption/generic-symmetric-key-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-symmetric-key-encoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/symmetric-encryption/generic-symmetric-key-encoder.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,sBAAsB,EAAC,MAAM,wBAAwB,CAAC;AAG9D;;;GAGG;AACH,qBAAa,0BAA0B;IAEnC;;;;;;;OAOG;IACH,kBAAkB,CAAC,GAAG,EAAE,sBAAsB,GAAG,UAAU;IAO3D;;;;;;OAMG;IACH,oBAAoB,CAAC,GAAG,EAAE,UAAU,GAAG,sBAAsB;CAUhE"}

package/dist/crypto/hash/hash-interface.d.ts

@@ -0,0 +1,12 @@
+export interface CryptographicHash {
+    getHashSchemeId(): CryptographicHashSchemeId;
+    hash(data: Uint8Array): Uint8Array;
+}
+export declare enum CryptographicHashSchemeId {
+    SHA256 = 0
+}
+export declare class Sha256CryptographicHash implements CryptographicHash {
+    getHashSchemeId(): CryptographicHashSchemeId;
+    hash(data: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=hash-interface.d.ts.map

package/dist/crypto/hash/hash-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-interface.d.ts","sourceRoot":"","sources":["../../../src/crypto/hash/hash-interface.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAC9B,eAAe,IAAI,yBAAyB,CAAC;IAC7C,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AAED,oBAAY,yBAAyB;IACjC,MAAM,IAAA;CACT;AAED,qBAAa,uBAAwB,YAAW,iBAAiB;IAC7D,eAAe,IAAI,yBAAyB;IAI5C,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;CAGrC"}

package/dist/crypto/hashes.d.ts

@@ -0,0 +1,12 @@
+export declare const Hashes: {
+    sha256AsBinary: typeof sha256AsBinary;
+    sha256: typeof sha256;
+    sha512AsBinary: typeof sha512AsBinary;
+    sha512: typeof sha512;
+};
+declare function sha256AsBinary(data: Uint8Array): Uint8Array;
+declare function sha256(data: Uint8Array): string;
+declare function sha512AsBinary(data: any): Uint8Array<ArrayBufferLike>;
+declare function sha512(data: any): string;
+export {};
+//# sourceMappingURL=hashes.d.ts.map

package/dist/crypto/hashes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.d.ts","sourceRoot":"","sources":["../../src/crypto/hashes.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM;;;;;CAKlB,CAAC;AAEF,iBAAS,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAQpD;AAED,iBAAS,MAAM,CAAC,IAAI,EAAE,UAAU,UAE/B;AAED,iBAAS,cAAc,CAAC,IAAI,EAAE,GAAG,+BAMhC;AAED,iBAAS,MAAM,CAAC,IAAI,EAAE,GAAG,UAExB"}

package/dist/crypto/kdf/HKDF.d.ts

@@ -0,0 +1,7 @@
+import { KeyDerivationFunction } from './KeyDerivationFunction';
+import { KeyDerivationFunctionSchemeId } from './keyDerivationFunctionSchemeId';
+export declare class HKDF extends KeyDerivationFunction {
+    getKeyDerivationFunctionSchemeId(): KeyDerivationFunctionSchemeId;
+    deriveKey(inputKeyingMaterial: Uint8Array, salt: Uint8Array, info: Uint8Array, keyLength: number): Uint8Array;
+}
+//# sourceMappingURL=HKDF.d.ts.map

package/dist/crypto/kdf/HKDF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HKDF.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/HKDF.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,qBAAqB,EAAC,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAC,6BAA6B,EAAC,MAAM,iCAAiC,CAAC;AAE9E,qBAAa,IAAK,SAAQ,qBAAqB;IAC3C,gCAAgC,IAAI,6BAA6B;IAIjE,SAAS,CAAC,mBAAmB,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;CAGhH"}

package/dist/crypto/kdf/KeyDerivationFunction.d.ts

@@ -0,0 +1,7 @@
+import { KeyDerivationFunctionSchemeId } from './keyDerivationFunctionSchemeId';
+export declare abstract class KeyDerivationFunction {
+    abstract getKeyDerivationFunctionSchemeId(): KeyDerivationFunctionSchemeId;
+    abstract deriveKey(inputKeyingMaterial: Uint8Array, salt: Uint8Array, info: Uint8Array, keyLength: number): Uint8Array;
+    deriveKeyNoSalt(inputKeyingMaterial: Uint8Array, info: Uint8Array, keyLength: number): Uint8Array;
+}
+//# sourceMappingURL=KeyDerivationFunction.d.ts.map

package/dist/crypto/kdf/KeyDerivationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyDerivationFunction.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/KeyDerivationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,6BAA6B,EAAC,MAAM,iCAAiC,CAAC;AAE9E,8BAAsB,qBAAqB;IACvC,QAAQ,CAAE,gCAAgC,IAAI,6BAA6B;IAC3E,QAAQ,CAAC,SAAS,CAAC,mBAAmB,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;IAC/G,eAAe,CAAC,mBAAmB,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;CAK3G"}

package/dist/crypto/kdf/PBKDF2.d.ts

@@ -0,0 +1,7 @@
+import { PasswordBasedKeyDerivationFunctionSchemeId } from './PasswordBasedKeyDerivationFunctionSchemeId';
+import { PasswordBasedKeyDerivationFunction } from './PasswordBasedKeyDerivationFunction';
+export declare class PBKDF2 extends PasswordBasedKeyDerivationFunction {
+    getKeyDerivationFunctionSchemeId(): PasswordBasedKeyDerivationFunctionSchemeId;
+    deriveKey(password: string, salt: string, keyLength: number): Uint8Array;
+}
+//# sourceMappingURL=PBKDF2.d.ts.map

package/dist/crypto/kdf/PBKDF2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PBKDF2.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/PBKDF2.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,0CAA0C,EAAC,MAAM,8CAA8C,CAAC;AACxG,OAAO,EAAC,kCAAkC,EAAC,MAAM,sCAAsC,CAAC;AAExF,qBAAa,MAAO,SAAQ,kCAAkC;IAC1D,gCAAgC,IAAI,0CAA0C;IAI9E,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;CAG3E"}

package/dist/crypto/kdf/PasswordBasedKeyDerivationFunction.d.ts

@@ -0,0 +1,7 @@
+import { PasswordBasedKeyDerivationFunctionSchemeId } from './PasswordBasedKeyDerivationFunctionSchemeId';
+export declare abstract class PasswordBasedKeyDerivationFunction {
+    abstract getKeyDerivationFunctionSchemeId(): PasswordBasedKeyDerivationFunctionSchemeId;
+    abstract deriveKey(password: string, salt: string, keyLength: number): Uint8Array;
+    deriveKeyNoSalt(password: string, keyLength: number): Uint8Array;
+}
+//# sourceMappingURL=PasswordBasedKeyDerivationFunction.d.ts.map

package/dist/crypto/kdf/PasswordBasedKeyDerivationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PasswordBasedKeyDerivationFunction.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/PasswordBasedKeyDerivationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,0CAA0C,EAAC,MAAM,8CAA8C,CAAC;AAExG,8BAAsB,kCAAkC;IACpD,QAAQ,CAAC,gCAAgC,IAAI,0CAA0C;IACvF,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;IACjF,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;CAInE"}

package/dist/crypto/kdf/PasswordBasedKeyDerivationFunctionSchemeId.d.ts

@@ -0,0 +1,5 @@
+export declare enum PasswordBasedKeyDerivationFunctionSchemeId {
+    PBKDF2 = 0,
+    SCRYPT = 1
+}
+//# sourceMappingURL=PasswordBasedKeyDerivationFunctionSchemeId.d.ts.map

package/dist/crypto/kdf/PasswordBasedKeyDerivationFunctionSchemeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PasswordBasedKeyDerivationFunctionSchemeId.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/PasswordBasedKeyDerivationFunctionSchemeId.ts"],"names":[],"mappings":"AAAA,oBAAY,0CAA0C;IAClD,MAAM,IAAA;IACN,MAAM,IAAA;CACT"}

package/dist/crypto/kdf/Scrypt.d.ts

@@ -0,0 +1,7 @@
+import { PasswordBasedKeyDerivationFunctionSchemeId } from './PasswordBasedKeyDerivationFunctionSchemeId';
+import { PasswordBasedKeyDerivationFunction } from './PasswordBasedKeyDerivationFunction';
+export declare class Scrypt extends PasswordBasedKeyDerivationFunction {
+    getKeyDerivationFunctionSchemeId(): PasswordBasedKeyDerivationFunctionSchemeId;
+    deriveKey(password: string, salt: string, keyLength: number): Uint8Array;
+}
+//# sourceMappingURL=Scrypt.d.ts.map

package/dist/crypto/kdf/Scrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scrypt.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/Scrypt.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,0CAA0C,EAAC,MAAM,8CAA8C,CAAC;AACxG,OAAO,EAAC,kCAAkC,EAAC,MAAM,sCAAsC,CAAC;AAExF,qBAAa,MAAO,SAAQ,kCAAkC;IAC1D,gCAAgC,IAAI,0CAA0C;IAI9E,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;CAG3E"}

package/dist/crypto/kdf/keyDerivationFunctionSchemeId.d.ts

@@ -0,0 +1,4 @@
+export declare enum KeyDerivationFunctionSchemeId {
+    HKDF = 0
+}
+//# sourceMappingURL=keyDerivationFunctionSchemeId.d.ts.map

package/dist/crypto/kdf/keyDerivationFunctionSchemeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyDerivationFunctionSchemeId.d.ts","sourceRoot":"","sources":["../../../src/crypto/kdf/keyDerivationFunctionSchemeId.ts"],"names":[],"mappings":"AAAA,oBAAY,6BAA6B;IACrC,IAAI,IAAA;CACP"}

package/dist/crypto/ml-dsa.d.ts

@@ -0,0 +1,13 @@
+export declare const MLDsa: {
+    generateKeyPair: typeof generateKeyPair;
+    sign: typeof sign;
+    verify: typeof verify;
+};
+declare function generateKeyPair(seed: any): {
+    publicKey: Uint8Array<ArrayBufferLike>;
+    privateKey: Uint8Array<ArrayBufferLike>;
+};
+declare function sign(privateKey: any, data: any): Uint8Array<ArrayBufferLike>;
+declare function verify(publicKey: any, data: any, signature: any): boolean;
+export {};
+//# sourceMappingURL=ml-dsa.d.ts.map

package/dist/crypto/ml-dsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ml-dsa.d.ts","sourceRoot":"","sources":["../../src/crypto/ml-dsa.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;;CAIjB,CAAC;AAEF,iBAAS,eAAe,CAAC,IAAI,EAAE,GAAG;;;EAQjC;AAED,iBAAS,IAAI,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,+BAEvC;AAED,iBAAS,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,WAExD"}

package/dist/crypto/ml-kem.d.ts

@@ -0,0 +1,16 @@
+export declare const MLKem: {
+    generateKeyPair: typeof generateKeyPair;
+    encapsulate: typeof encapsulate;
+    decapsulate: typeof decapsulate;
+};
+declare function generateKeyPair(seed: any): {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+};
+declare function encapsulate(publicKey: any): {
+    cipherText: Uint8Array;
+    sharedSecret: Uint8Array;
+};
+declare function decapsulate(cipherText: any, privateKey: any): Uint8Array<ArrayBufferLike>;
+export {};
+//# sourceMappingURL=ml-kem.d.ts.map

package/dist/crypto/ml-kem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ml-kem.d.ts","sourceRoot":"","sources":["../../src/crypto/ml-kem.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;;CAIjB,CAAC;AAEF,iBAAS,eAAe,CAAC,IAAI,EAAE,GAAG;;;EAQjC;AAED,iBAAS,WAAW,CAAC,SAAS,EAAE,GAAG;;;EAElC;AAED,iBAAS,WAAW,CAAC,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,+BAEpD"}

package/dist/crypto/random.d.ts

@@ -0,0 +1,10 @@
+export declare const Random: {
+    getBytes: typeof getBytes;
+    getInteger: typeof getInteger;
+    getKey256: typeof getKey256;
+};
+declare function getBytes(n: any): Uint8Array<ArrayBufferLike>;
+declare function getInteger(max: any): number;
+declare function getKey256(): string;
+export {};
+//# sourceMappingURL=random.d.ts.map

package/dist/crypto/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src/crypto/random.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM;;;;CAIlB,CAAC;AAEF,iBAAS,QAAQ,CAAC,CAAC,EAAE,GAAG,+BAEvB;AAED,iBAAS,UAAU,CAAC,GAAG,EAAE,GAAG,UAS3B;AAED,iBAAS,SAAS,WAIjB"}

package/dist/crypto/secp256k1.d.ts

@@ -0,0 +1,10 @@
+export declare const Secp256k1: {
+    publicKeyFromPrivateKey: typeof publicKeyFromPrivateKey;
+    sign: typeof sign;
+    verify: typeof verify;
+};
+declare function publicKeyFromPrivateKey(privateKey: any): import('@noble/secp256k1').Bytes;
+declare function sign(privateKey: any, data: any): import('@noble/secp256k1').Bytes;
+declare function verify(publicKey: any, data: any, signature: any): boolean;
+export {};
+//# sourceMappingURL=secp256k1.d.ts.map

package/dist/crypto/secp256k1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.d.ts","sourceRoot":"","sources":["../../src/crypto/secp256k1.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS;;;;CAIrB,CAAC;AAEF,iBAAS,uBAAuB,CAAC,UAAU,EAAE,GAAG,oCAE/C;AAED,iBAAS,IAAI,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,oCAKvC;AAED,iBAAS,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,WAIxD"}

package/dist/crypto/signature/BasePrivateSignatureKey.d.ts

@@ -0,0 +1,27 @@
+import { PrivateSignatureKey } from './PrivateSignatureKey';
+import { SignatureScheme } from './SignatureScheme';
+import { PublicSignatureKey } from './PublicSignatureKey';
+import { EncoderInterface } from '../../utils/encoder';
+import { SignatureSchemeId } from './SignatureSchemeId';
+/**
+ * Abstract base class representing a private signature key. It provides
+ * methods for retrieving the private key, generating signatures, and
+ * accessing associated metadata and functionalities related to the
+ * signature scheme.
+ */
+export declare abstract class BasePrivateSignatureKey implements PrivateSignatureKey {
+    abstract getPrivateKeyAsBytes(): Uint8Array;
+    abstract sign(data: Uint8Array): Promise<Uint8Array>;
+    abstract getScheme(): SignatureScheme;
+    abstract getPublicKey(): Promise<PublicSignatureKey>;
+    getPrivateKeyAsString(encoder?: EncoderInterface<Uint8Array, string>): string;
+    getSignatureSchemeId(): SignatureSchemeId;
+    getSignatureSize(): number;
+    /**
+     * @deprecated Use getSignatureSchemeId instead.
+     *
+     * @returns
+     */
+    getSignatureAlgorithmId(): SignatureSchemeId;
+}
+//# sourceMappingURL=BasePrivateSignatureKey.d.ts.map

package/dist/crypto/signature/BasePrivateSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasePrivateSignatureKey.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/BasePrivateSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAiB,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;;;GAKG;AACH,8BAAsB,uBAAwB,YAAW,mBAAmB;IACxE,QAAQ,CAAC,oBAAoB,IAAI,UAAU;IAE3C,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAEpD,QAAQ,CAAC,SAAS,IAAI,eAAe;IAErC,QAAQ,CAAC,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAEpD,qBAAqB,CAAC,OAAO,GAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAgD,GAAG,MAAM;IAI3H,oBAAoB,IAAI,iBAAiB;IAIzC,gBAAgB,IAAI,MAAM;IAI1B;;;;OAIG;IACH,uBAAuB,IAAI,iBAAiB;CAI/C"}

package/dist/crypto/signature/BasePublicSignatureKey.d.ts

@@ -0,0 +1,24 @@
+import { PublicSignatureKey } from './PublicSignatureKey';
+import { EncoderInterface } from '../../utils/encoder';
+import { SignatureScheme } from './SignatureScheme';
+import { SignatureSchemeId } from './SignatureSchemeId';
+/**
+ * Abstract class representing the base implementation of a public signature key.
+ * This class provides a partial implementation for handling public keys and signing operations.
+ * It serves as a foundation for specific public signature key implementations.
+ */
+export declare abstract class BasePublicSignatureKey implements PublicSignatureKey {
+    getPublicKeyAsString(encoder?: EncoderInterface<Uint8Array, string>): Promise<string>;
+    abstract getPublicKeyAsBytes(): Promise<Uint8Array>;
+    abstract verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+    abstract getScheme(): SignatureScheme;
+    getSignatureSize(): number;
+    getSignatureSchemeId(): SignatureSchemeId;
+    /**
+     * @deprecated Use getSignatureSchemeId instead.
+     *
+     * @returns
+     */
+    getSignatureAlgorithmId(): SignatureSchemeId;
+}
+//# sourceMappingURL=BasePublicSignatureKey.d.ts.map

package/dist/crypto/signature/BasePublicSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasePublicSignatureKey.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/BasePublicSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAiB,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,8BAAsB,sBAAuB,YAAW,kBAAkB;IAChE,oBAAoB,CAAC,OAAO,GAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAgD,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzI,QAAQ,CAAC,mBAAmB,IAAI,OAAO,CAAC,UAAU,CAAC;IAEnD,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAE1E,QAAQ,CAAC,SAAS,IAAI,eAAe;IAErC,gBAAgB,IAAI,MAAM;IAI1B,oBAAoB,IAAI,iBAAiB;IAIzC;;;;OAIG;IACH,uBAAuB,IAAI,iBAAiB;CAG/C"}

package/dist/crypto/signature/PrivateSignatureKey.d.ts

@@ -0,0 +1,17 @@
+import { SignatureScheme } from './SignatureScheme';
+import { PublicSignatureKey } from './PublicSignatureKey';
+import { SignatureSchemeId } from './SignatureSchemeId';
+/**
+ * Represents a private signature key utilized in cryptographic operations.
+ *
+ * This interface extends the `SignatureScheme` and provides functionality
+ * to generate a corresponding public key and to sign data.
+ */
+export interface PrivateSignatureKey {
+    getScheme(): SignatureScheme;
+    getPublicKey(): Promise<PublicSignatureKey>;
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    getPrivateKeyAsBytes(): Uint8Array;
+    getSignatureSchemeId(): SignatureSchemeId;
+}
+//# sourceMappingURL=PrivateSignatureKey.d.ts.map

package/dist/crypto/signature/PrivateSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrivateSignatureKey.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/PrivateSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAChC,SAAS,IAAI,eAAe,CAAC;IAC7B,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC5C,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,oBAAoB,IAAI,UAAU,CAAC;IACnC,oBAAoB,IAAI,iBAAiB,CAAC;CAC7C"}

package/dist/crypto/signature/PublicSignatureKey.d.ts

@@ -0,0 +1,27 @@
+import { SignatureScheme } from './SignatureScheme';
+import { SignatureSchemeId } from './SignatureSchemeId';
+/**
+ * Represents a public signature key adhering to a specific signature scheme.
+ * This interface provides methods to verify digital signatures and fetch the raw public key.
+ *
+ * @interface PublicSignatureKey
+ * @extends SignatureScheme
+ *
+ * @method verify
+ *   Verifies the digital signature for the provided data.
+ *   @param {Uint8Array} data - The original data to be verified.
+ *   @param {Uint8Array} signature - The digital signature corresponding to the provided data.
+ *   @returns {boolean} - Returns true if the signature is valid for the data, false otherwise.
+ *
+ * @method getPublicKeyAsBytes
+ *   Retrieves the raw representation of the public key.
+ *   This is useful for serialization, transmission, or other forms of key processing.
+ *   @returns {Uint8Array} - The raw bytes of the public key.
+ */
+export interface PublicSignatureKey {
+    getScheme(): SignatureScheme;
+    verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+    getPublicKeyAsBytes(): Promise<Uint8Array>;
+    getSignatureSchemeId(): SignatureSchemeId;
+}
+//# sourceMappingURL=PublicSignatureKey.d.ts.map

package/dist/crypto/signature/PublicSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PublicSignatureKey.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/PublicSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,kBAAkB;IAC/B,SAAS,IAAI,eAAe,CAAC;IAE7B,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAElE,mBAAmB,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAE3C,oBAAoB,IAAI,iBAAiB,CAAC;CAC7C"}

package/dist/crypto/signature/SignatureAlgorithmId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @deprecated Will be removed soon!
+ */
+export declare enum SignatureAlgorithmId {
+    SECP256K1 = 0,
+    ML_DSA_65 = 1
+}
+//# sourceMappingURL=SignatureAlgorithmId.d.ts.map

package/dist/crypto/signature/SignatureAlgorithmId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureAlgorithmId.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/SignatureAlgorithmId.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,oBAAY,oBAAoB;IAC5B,SAAS,IAA8B;IACvC,SAAS,IAA8B;CAC1C"}

package/dist/crypto/signature/SignatureScheme.d.ts

@@ -0,0 +1,11 @@
+import { SignatureSchemeId } from './SignatureSchemeId';
+/**
+ * Represents a cryptographic signature scheme with methods to retrieve
+ * identifying information and utilities for encoding public keys.
+ */
+export interface SignatureScheme {
+    getSignatureSchemeId(): SignatureSchemeId;
+    expectedSeedSize(): number;
+    getSignatureSize(): number;
+}
+//# sourceMappingURL=SignatureScheme.d.ts.map

package/dist/crypto/signature/SignatureScheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureScheme.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/SignatureScheme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC5B,oBAAoB,IAAI,iBAAiB,CAAC;IAC1C,gBAAgB,IAAI,MAAM,CAAC;IAC3B,gBAAgB,IAAI,MAAM,CAAC;CAC9B"}

package/dist/crypto/signature/SignatureSchemeId.d.ts

@@ -0,0 +1,16 @@
+/**
+ * An enumeration representing the identifiers for different signature algorithms.
+ * This enum is used to indicate the type of cryptographic signature algorithm being utilized.
+ *
+ * Enum members:
+ * - SECP256K1: Indicates the SECP256K1 signature algorithm, typically associated with elliptic-curve cryptography.
+ * - ML_DSA_65: Represents the ML-DSA-65 signature algorithm.
+ * - PKMS_SECP256K1: Represents the P(roxy)KMS-based SECP256K1 signature algorithm.
+ */
+export declare enum SignatureSchemeId {
+    SECP256K1 = 0,
+    ML_DSA_65 = 1,
+    PKMS_SECP256K1 = 2,
+    ED25519 = 3
+}
+//# sourceMappingURL=SignatureSchemeId.d.ts.map

package/dist/crypto/signature/SignatureSchemeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureSchemeId.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/SignatureSchemeId.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oBAAY,iBAAiB;IACzB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,cAAc,IAAI;IAClB,OAAO,IAAI;CACd"}

package/dist/crypto/signature/ed25519/Ed25519PrivateSignatureKey.d.ts

@@ -0,0 +1,38 @@
+import { Bytes } from '@noble/ed25519';
+import { BasePrivateSignatureKey } from '../BasePrivateSignatureKey';
+import { EncoderInterface } from '../../../utils/encoder';
+import { PublicSignatureKey } from '../PublicSignatureKey';
+import { SignatureScheme } from '../SignatureScheme';
+/**
+ * Represents a private signature key using the Ed25519 curve. This class extends
+ * from `Ed25519PublicSignatureKey` and implements the `PrivateSignatureKey` interface.
+ * It provides functionality to generate a private key, derive its corresponding
+ * public key, and sign data.
+ *
+ * Methods enable key generation, retrieving the associated public key,
+ * and signing cryptographic hashes.
+ */
+export declare class Ed25519PrivateSignatureKey extends BasePrivateSignatureKey {
+    private privateKey;
+    constructor(privateKey: Bytes);
+    getPrivateKeyAsString(encoder: EncoderInterface<Uint8Array, string>): string;
+    /**
+     * Generates and returns a new instance of Ed25519PrivateSignatureKey
+     * initialized with a randomly generated private key.
+     *
+     * @return {Ed25519PrivateSignatureKey} A new Ed25519PrivateSignatureKey object.
+     */
+    static gen(): Ed25519PrivateSignatureKey;
+    /**
+     * Generates a Ed25519 private signature key from a given seed.
+     *
+     * @param {Uint8Array} seed - The seed used to generate the private key.
+     * @return {Ed25519PrivateSignatureKey} The generated Ed25519 private signature key.
+     */
+    static genFromSeed(seed: Uint8Array): Ed25519PrivateSignatureKey;
+    getPublicKey(): Promise<PublicSignatureKey>;
+    getPrivateKeyAsBytes(): Uint8Array;
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    getScheme(): SignatureScheme;
+}
+//# sourceMappingURL=Ed25519PrivateSignatureKey.d.ts.map

package/dist/crypto/signature/ed25519/Ed25519PrivateSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519PrivateSignatureKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/ed25519/Ed25519PrivateSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,EAA6B,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAC,uBAAuB,EAAC,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AAKnD;;;;;;;;GAQG;AACH,qBAAa,0BAA2B,SAAQ,uBAAuB;IACvD,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,KAAK;IAIrC,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM;IAI5E;;;;;OAKG;IACH,MAAM,CAAC,GAAG,IAAI,0BAA0B;IAIxC;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU;IAI7B,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAKjD,oBAAoB,IAAI,UAAU;IAK5B,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAKjD,SAAS,IAAI,eAAe;CAG/B"}