@enbox/agent 0.1.2 → 0.1.4

package/dist/types/prototyping/crypto/algorithms/eddsa.d.ts

@@ -1,157 +0,0 @@
-import type { AsymmetricKeyConverter, AsymmetricKeyGenerator, ComputePublicKeyParams, GenerateKeyParams, GetPublicKeyParams, Jwk, KeyConverter, Signer, SignParams, VerifyParams } from '@enbox/crypto';
-import { CryptoAlgorithm } from '@enbox/crypto';
-import type { BytesToPrivateKeyParams, BytesToPublicKeyParams, PrivateKeyToBytesParams, PublicKeyToBytesParams } from '../types/params-direct.js';
-/**
- * The `EdDsaGenerateKeyParams` interface defines the algorithm-specific parameters that should be
- * passed into the `generateKey()` method when using the EdDSA algorithm.
- */
-export interface EdDsaGenerateKeyParams extends GenerateKeyParams {
-    /**
-     * A string defining the type of key to generate. The value must be one of the following:
-     * - `"Ed25519"`: EdDSA using the Ed25519 curve.
-     */
-    algorithm: 'Ed25519';
-}
-/**
- * The `EdDsaAlgorithm` class provides a concrete implementation for cryptographic operations using
- * the Edwards-curve Digital Signature Algorithm (EdDSA). This class implements both
- * {@link Signer | `Signer`} and { @link AsymmetricKeyGenerator | `AsymmetricKeyGenerator`}
- * interfaces, providing private key generation, public key derivation, and creation/verification
- * of signatures.
- *
- * This class is typically accessed through implementations that extend the
- * {@link CryptoApi | `CryptoApi`} interface.
- */
-export declare class EdDsaAlgorithm extends CryptoAlgorithm implements AsymmetricKeyGenerator<EdDsaGenerateKeyParams, Jwk, GetPublicKeyParams>, KeyConverter, AsymmetricKeyConverter, Signer<SignParams, VerifyParams> {
-    bytesToPrivateKey({ algorithm, privateKeyBytes }: BytesToPrivateKeyParams & {
-        algorithm: 'Ed25519';
-    }): Promise<Jwk>;
-    bytesToPublicKey({ algorithm, publicKeyBytes }: BytesToPublicKeyParams & {
-        algorithm: 'Ed25519';
-    }): Promise<Jwk>;
-    /**
-     * Derives the public key in JWK format from a given private key.
-     *
-     * @remarks
-     * This method takes a private key in JWK format and derives its corresponding public key,
-     * also in JWK format. The process ensures that the derived public key correctly corresponds to
-     * the given private key.
-     *
-     * @example
-     * ```ts
-     * const eddsa = new EdDsaAlgorithm();
-     * const privateKey = { ... }; // A Jwk object representing a private key
-     * const publicKey = await eddsa.computePublicKey({ key: privateKey });
-     * ```
-     *
-     * @param params - The parameters for the public key derivation.
-     * @param params.key - The private key in JWK format from which to derive the public key.
-     *
-     * @returns A Promise that resolves to the derived public key in JWK format.
-     */
-    computePublicKey({ key }: ComputePublicKeyParams): Promise<Jwk>;
-    /**
-     * Generates a new private key with the specified algorithm in JSON Web Key (JWK) format.
-     *
-     * @example
-     * ```ts
-     * const eddsa = new EdDsaAlgorithm();
-     * const privateKey = await eddsa.generateKey({ algorithm: 'Ed25519' });
-     * ```
-     *
-     * @param params - The parameters for key generation.
-     * @param params.algorithm - The algorithm to use for key generation.
-     *
-     * @returns A Promise that resolves to the generated private key in JWK format.
-     */
-    generateKey({ algorithm }: EdDsaGenerateKeyParams): Promise<Jwk>;
-    /**
-     * Retrieves the public key properties from a given private key in JWK format.
-     *
-     * @remarks
-     * This method extracts the public key portion from an EdDSA private key in JWK format. It does
-     * so by removing the private key property 'd' and making a shallow copy, effectively yielding the
-     * public key.
-     *
-     * Note: This method offers a significant performance advantage, being about 100 times faster
-     * than `computePublicKey()`. However, it does not mathematically validate the private key, nor
-     * does it derive the public key from the private key. It simply extracts existing public key
-     * properties from the private key object. This makes it suitable for scenarios where speed is
-     * critical and the private key's integrity is already assured.
-     *
-     * @example
-     * ```ts
-     * const eddsa = new EdDsaAlgorithm();
-     * const privateKey = { ... }; // A Jwk object representing a private key
-     * const publicKey = await eddsa.getPublicKey({ key: privateKey });
-     * ```
-     *
-     * @param params - The parameters for retrieving the public key properties.
-     * @param params.key - The private key in JWK format.
-     *
-     * @returns A Promise that resolves to the public key in JWK format.
-     */
-    getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
-    privateKeyToBytes({ privateKey }: PrivateKeyToBytesParams): Promise<Uint8Array>;
-    publicKeyToBytes({ publicKey }: PublicKeyToBytesParams): Promise<Uint8Array>;
-    /**
-     * Generates an EdDSA signature of given data using a private key.
-     *
-     * @remarks
-     * This method uses the signature algorithm determined by the given `algorithm` to sign the
-     * provided data.
-     *
-     * The signature can later be verified by parties with access to the corresponding
-     * public key, ensuring that the data has not been tampered with and was indeed signed by the
-     * holder of the private key.
-     *
-     * @example
-     * ```ts
-     * const eddsa = new EdDsaAlgorithm();
-     * const data = new TextEncoder().encode('Message');
-     * const privateKey = { ... }; // A Jwk object representing a private key
-     * const signature = await eddsa.sign({
-     *   key: privateKey,
-     *   data
-     * });
-     * ```
-     *
-     * @param params - The parameters for the signing operation.
-     * @param params.key - The private key to use for signing, represented in JWK format.
-     * @param params.data - The data to sign.
-     *
-     * @returns A Promise resolving to the digital signature as a `Uint8Array`.
-     */
-    sign({ key, data }: SignParams): Promise<Uint8Array>;
-    /**
-     * Verifies an EdDSA signature associated with the provided data using the provided key.
-     *
-     * @remarks
-     * This method uses the signature algorithm determined by the `crv` property of the provided key
-     * to check the validity of a digital signature against the original data. It confirms whether the
-     * signature was created by the holder of the corresponding private key and that the data has not
-     * been tampered with.
-     *s
-     * @example
-     * ```ts
-     * const eddsa = new EdDsaAlgorithm();
-     * const publicKey = { ... }; // Public key in JWK format corresponding to the private key that signed the data
-     * const signature = new Uint8Array([...]); // Signature to verify
-     * const data = new TextEncoder().encode('Message');
-     * const isValid = await eddsa.verify({
-     *   key: publicKey,
-     *   signature,
-     *   data
-     * });
-     * ```
-     *
-     * @param params - The parameters for the verification operation.
-     * @param params.key - The key to use for verification.
-     * @param params.signature - The signature to verify.
-     * @param params.data - The data to verify.
-     *
-     * @returns A Promise resolving to a boolean indicating whether the signature is valid.
-     */
-    verify({ key, signature, data }: VerifyParams): Promise<boolean>;
-}
-//# sourceMappingURL=eddsa.d.ts.map

package/dist/types/prototyping/crypto/algorithms/eddsa.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/eddsa.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,GAAG,EACH,YAAY,EACZ,MAAM,EACN,UAAU,EACV,YAAY,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAA4C,MAAM,eAAe,CAAC;AAE1F,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAGlJ;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D;;;OAGG;IACH,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,eAClC,YAAW,sBAAsB,CAAC,sBAAsB,EAAE,GAAG,EAAE,kBAAkB,CAAC,EACvE,YAAY,EAAE,sBAAsB,EACpC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC;IAE9B,iBAAiB,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,EAC3D,uBAAuB,GAAG;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,GACjD,OAAO,CAAC,GAAG,CAAC;IAeF,gBAAgB,CAAC,EAAE,SAAS,EAAE,cAAc,EAAE,EACzD,sBAAsB,GAAG;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,GAChD,OAAO,CAAC,GAAG,CAAC;IAef;;;;;;;;;;;;;;;;;;;OAmBG;IACU,gBAAgB,CAAC,EAAE,GAAG,EAAE,EACnC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAiBf;;;;;;;;;;;;;OAaG;IACG,WAAW,CAAC,EAAE,SAAS,EAAE,EAC7B,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAWf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,YAAY,CAAC,EAAE,GAAG,EAAE,EAC/B,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAiBF,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAC3C,uBAAuB,GACtB,OAAO,CAAC,UAAU,CAAC;IAaT,gBAAgB,CAAC,EAAE,SAAS,EAAE,EACzC,sBAAsB,GACrB,OAAO,CAAC,UAAU,CAAC;IAatB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACU,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAC7B,UAAU,GACT,OAAO,CAAC,UAAU,CAAC;IAetB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACU,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAC1C,YAAY,GACX,OAAO,CAAC,OAAO,CAAC;CAcpB"}

package/dist/types/prototyping/crypto/algorithms/hkdf.d.ts

@@ -1,20 +0,0 @@
-import type { KeyBytesDeriver } from '../types/key-deriver.js';
-import type { DeriveKeyBytesParams, HkdfParams } from '@enbox/crypto';
-import { CryptoAlgorithm } from '@enbox/crypto';
-/**
- * The `HkdfDeriveKeyBytesParams` interface defines the algorithm-specific parameters that should be
- * passed into the `deriveKeyBytes()` method when using the HKDF algorithm.
- */
-export interface HkdfDeriveKeyBytesParams extends DeriveKeyBytesParams {
-    /** Specifies the algorithm variant for HKDF key derivation.
-     * The value determines the hash function that will be used and must be one of the following:
-     * - `"HKDF-256"`: HKDF with SHA-256.
-     * - `"HKDF-384"`: HKDF with SHA-384.
-     * - `"HKDF-512"`: HKDF with SHA-512.
-     */
-    algorithm: 'HKDF-256' | 'HKDF-384' | 'HKDF-512';
-}
-export declare class HkdfAlgorithm extends CryptoAlgorithm implements KeyBytesDeriver<HkdfDeriveKeyBytesParams, Uint8Array> {
-    deriveKeyBytes({ algorithm, ...params }: HkdfDeriveKeyBytesParams & Omit<HkdfParams, 'hash'>): Promise<Uint8Array>;
-}
-//# sourceMappingURL=hkdf.d.ts.map

package/dist/types/prototyping/crypto/algorithms/hkdf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hkdf.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/hkdf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEtE,OAAO,EAAE,eAAe,EAAQ,MAAM,eAAe,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE;;;;;OAKG;IACH,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;CACjD;AAED,qBAAa,aAAc,SAAQ,eACjC,YAAW,eAAe,CAAC,wBAAwB,EAAE,UAAU,CAAC;IAEnD,cAAc,CAAC,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,EAClD,wBAAwB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAClD,OAAO,CAAC,UAAU,CAAC;CAavB"}

package/dist/types/prototyping/crypto/algorithms/pbkdf2.d.ts

@@ -1,20 +0,0 @@
-import type { KeyBytesDeriver } from '../types/key-deriver.js';
-import type { DeriveKeyBytesParams, Pbkdf2Params } from '@enbox/crypto';
-import { CryptoAlgorithm } from '@enbox/crypto';
-/**
- * The `Pbkdf2DeriveKeyBytesParams` interface defines the algorithm-specific parameters that
- * should be passed into the `deriveKeyBytes()` method when using the PBKDF2 algorithm.
- */
-export interface Pbkdf2DeriveKeyBytesParams extends DeriveKeyBytesParams {
-    /** Specifies the algorithm variant for PBKDF2 key derivation.
-     * The value determines the hash function that will be used and must be one of the following:
-     * - `"PBKDF2-HS256+A128KW"`: PBKDF2 with HMAC SHA-256 and A128KW key wrapping.
-     * - `"PBKDF2-HS384+A192KW"`: PBKDF2 with HMAC SHA-384 and A192KW key wrapping.
-     * - `"PBKDF2-HS512+A256KW"`: PBKDF2 with HMAC SHA-512 and A256KW key wrapping.
-     */
-    algorithm: 'PBES2-HS256+A128KW' | 'PBES2-HS384+A192KW' | 'PBES2-HS512+A256KW';
-}
-export declare class Pbkdf2Algorithm extends CryptoAlgorithm implements KeyBytesDeriver<Pbkdf2DeriveKeyBytesParams, Uint8Array> {
-    deriveKeyBytes({ algorithm, ...params }: Pbkdf2DeriveKeyBytesParams & Omit<Pbkdf2Params, 'hash'>): Promise<Uint8Array>;
-}
-//# sourceMappingURL=pbkdf2.d.ts.map

package/dist/types/prototyping/crypto/algorithms/pbkdf2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/pbkdf2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAExE,OAAO,EAAE,eAAe,EAAU,MAAM,eAAe,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,oBAAoB;IACtE;;;;;OAKG;IACH,SAAS,EAAE,oBAAoB,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;CAC/E;AAED,qBAAa,eAAgB,SAAQ,eACnC,YAAW,eAAe,CAAC,0BAA0B,EAAE,UAAU,CAAC;IAErD,cAAc,CAAC,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,EAClD,0BAA0B,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GACtD,OAAO,CAAC,UAAU,CAAC;CAgBvB"}

package/dist/types/prototyping/crypto/crypto-error.d.ts

@@ -1,29 +0,0 @@
-/**
- * A custom error class for Crypto-related errors.
- */
-export declare class CryptoError extends Error {
-    code: CryptoErrorCode;
-    /**
-     * Constructs an instance of CryptoError, a custom error class for handling Crypto-related errors.
-     *
-     * @param code - A {@link CryptoErrorCode} representing the specific type of error encountered.
-     * @param message - A human-readable description of the error.
-     */
-    constructor(code: CryptoErrorCode, message: string);
-}
-/**
- * An enumeration of possible Crypto error codes.
- */
-export declare enum CryptoErrorCode {
-    /** The supplied algorithm identifier is not supported by the implementation. */
-    AlgorithmNotSupported = "algorithmNotSupported",
-    /** The encoding operation (either encoding or decoding) failed. */
-    EncodingError = "encodingError",
-    /** The JWE supplied does not conform to valid syntax. */
-    InvalidJwe = "invalidJwe",
-    /** The JWK supplied does not conform to valid syntax. */
-    InvalidJwk = "invalidJwk",
-    /** The requested operation is not supported by the implementation. */
-    OperationNotSupported = "operationNotSupported"
-}
-//# sourceMappingURL=crypto-error.d.ts.map

package/dist/types/prototyping/crypto/crypto-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crypto-error.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/crypto/crypto-error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAOjB,IAAI,EAAE,eAAe;IANxC;;;;;OAKG;gBACgB,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM;CAc1D;AAED;;GAEG;AACH,oBAAY,eAAe;IACzB,gFAAgF;IAChF,qBAAqB,0BAA0B;IAE/C,mEAAmE;IACnE,aAAa,kBAAkB;IAE/B,yDAAyD;IACzD,UAAU,eAAe;IAEzB,yDAAyD;IACzD,UAAU,eAAe;IAEzB,sEAAsE;IACtE,qBAAqB,0BAA0B;CAChD"}

package/dist/types/prototyping/crypto/types/crypto-api.d.ts

@@ -1,34 +0,0 @@
-import type { Cipher, DigestParams, GenerateKeyParams, GetPublicKeyParams, Jwk, KeyWrapper, CryptoApi as OldCryptoApi, SignParams, VerifyParams } from '@enbox/crypto';
-import type { AsymmetricKeyConverter, KeyConverter } from './key-converter.js';
-import type { BytesToPrivateKeyParams, BytesToPublicKeyParams, CipherParams, DeriveKeyBytesParams, DeriveKeyParams, PrivateKeyToBytesParams, PublicKeyToBytesParams, UnwrapKeyParams, WrapKeyParams } from './params-direct.js';
-import type { KeyBytesDeriver, KeyDeriver } from './key-deriver.js';
-/**
- * The `DsaApi` interface integrates key generation, hashing, and signing functionalities,
- * designed for use with a Key Management System (KMS). It extends `AsymmetricKeyGenerator` for
- * generating asymmetric keys, `Hasher` for hash digest computations, and `Signer` for signing and
- * verifying operations.
- *
- * Concrete implementations of this interface are intended to be used with a KMS, which is
- * responsible for generating and storing cryptographic keys. The KMS is also responsible for
- * performing cryptographic operations using the keys it manages. The KMS is typically a cloud
- * service, but it can also be a hardware device or software application.
- *
- * Guidelines for implementing this interface:
- * - Must use JSON Web Keys ({@link Jwk | JWK}) as the key format.
- * - Must IANA registered JSON Object Signing and Encryption
- *   {@ link https://www.iana.org/assignments/jose/jose.xhtml#web-signature-encryption-algorithms | (JOSE)}
- *   names for algorithm, curves, etc. whenever possible.
- * - All I/O that interacts with private or secret keys must be done via reference using a
- *   {@link KeyIdentifier | `KeyIdentifier`}. Implementations can use any string as the key
- *   identifier (e.g. JWK thumbprint, UUID generated by hosted KMS, etc.).
- * - Must support key generation, hashing, signing, and verifying operations.
- * - May be extended to support other cryptographic operations.
- * - Implementations of the `DsaApi` interface can be passed as an argument to the public API
- *   methods of Web5 libraries that involve key material (e.g., DID creation, VC signing, arbitrary
- *   data signing/verification, etc.).
- */
-export interface DsaApi<GenerateKeyInput = GenerateKeyParams, GenerateKeyOutput = Jwk, GetPublicKeyInput = GetPublicKeyParams, DigestInput = DigestParams, SignInput = SignParams, VerifyInput = VerifyParams> extends OldCryptoApi<GenerateKeyInput, GenerateKeyOutput, GetPublicKeyInput, DigestInput, SignInput, VerifyInput> {
-}
-export interface CryptoApi<GenerateKeyInput = GenerateKeyParams, GenerateKeyOutput = Jwk, GetPublicKeyInput = GetPublicKeyParams, DigestInput = DigestParams, SignInput = SignParams, VerifyInput = VerifyParams, EncryptInput = CipherParams, DecryptInput = CipherParams, BytesToPublicKeyInput = BytesToPublicKeyParams, PublicKeyToBytesInput = PublicKeyToBytesParams, BytesToPrivateKeyInput = BytesToPrivateKeyParams, PrivateKeyToBytesInput = PrivateKeyToBytesParams, DeriveKeyInput = DeriveKeyParams, DeriveKeyOutput = Jwk, DeriveKeyBytesInput = DeriveKeyBytesParams, DeriveKeyBytesOutput = Uint8Array, WrapKeyInput = WrapKeyParams, UnwrapKeyInput = UnwrapKeyParams> extends DsaApi<GenerateKeyInput, GenerateKeyOutput, GetPublicKeyInput, DigestInput, SignInput, VerifyInput>, Cipher<EncryptInput, DecryptInput>, AsymmetricKeyConverter<BytesToPublicKeyInput, PublicKeyToBytesInput>, KeyConverter<BytesToPrivateKeyInput, PrivateKeyToBytesInput>, KeyDeriver<DeriveKeyInput, DeriveKeyOutput>, KeyBytesDeriver<DeriveKeyBytesInput, DeriveKeyBytesOutput>, KeyWrapper<WrapKeyInput, UnwrapKeyInput> {
-}
-//# sourceMappingURL=crypto-api.d.ts.map

package/dist/types/prototyping/crypto/types/crypto-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crypto-api.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/types/crypto-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,GAAG,EACH,UAAU,EACV,SAAS,IAAI,YAAY,EACzB,UAAU,EACV,YAAY,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAChO,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,MAAM,CACrB,gBAAgB,GAAG,iBAAiB,EACpC,iBAAiB,GAAG,GAAG,EACvB,iBAAiB,GAAG,kBAAkB,EACtC,WAAW,GAAG,YAAY,EAC1B,SAAS,GAAG,UAAU,EACtB,WAAW,GAAG,YAAY,CAC1B,SAAQ,YAAY,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,CAAC;CAAG;AAEtH,MAAM,WAAW,SAAS,CACxB,gBAAgB,GAAG,iBAAiB,EACpC,iBAAiB,GAAG,GAAG,EACvB,iBAAiB,GAAG,kBAAkB,EACtC,WAAW,GAAG,YAAY,EAC1B,SAAS,GAAG,UAAU,EACtB,WAAW,GAAG,YAAY,EAC1B,YAAY,GAAG,YAAY,EAC3B,YAAY,GAAG,YAAY,EAC3B,qBAAqB,GAAG,sBAAsB,EAC9C,qBAAqB,GAAG,sBAAsB,EAC9C,sBAAsB,GAAG,uBAAuB,EAChD,sBAAsB,GAAG,uBAAuB,EAChD,cAAc,GAAG,eAAe,EAChC,eAAe,GAAG,GAAG,EACrB,mBAAmB,GAAG,oBAAoB,EAC1C,oBAAoB,GAAG,UAAU,EACjC,YAAY,GAAG,aAAa,EAC5B,cAAc,GAAG,eAAe,CAChC,SACA,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,CAAC,EACnG,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,EAClC,sBAAsB,CAAC,qBAAqB,EAAE,qBAAqB,CAAC,EACpE,YAAY,CAAC,sBAAsB,EAAE,sBAAsB,CAAC,EAC5D,UAAU,CAAC,cAAc,EAAE,eAAe,CAAC,EAC3C,eAAe,CAAC,mBAAmB,EAAE,oBAAoB,CAAC,EAC1D,UAAU,CAAC,YAAY,EAAE,cAAc,CAAC;CAAG"}

package/dist/types/prototyping/crypto/types/key-converter.d.ts

@@ -1,49 +0,0 @@
-import type { Jwk } from '@enbox/crypto';
-/**
- * `KeyConverter` interface for converting private keys between byte array and JWK formats.
- */
-export interface KeyConverter<BytesToPrivateKeyInput, PrivateKeyToBytesInput> {
-    /**
-     * Converts a private key from a byte array to JWK format.
-     *
-     * @param params - The parameters for the private key conversion.
-     * @param params.privateKeyBytes - The raw private key as a Uint8Array.
-     *
-     * @returns A Promise that resolves to the private key in JWK format.
-     */
-    bytesToPrivateKey(params: BytesToPrivateKeyInput): Promise<Jwk>;
-    /**
-     * Converts a private key from JWK format to a byte array.
-     *
-     * @param params - The parameters for the private key conversion.
-     * @param params.privateKey - The private key in JWK format.
-     *
-     * @returns A Promise that resolves to the private key as a Uint8Array.
-     */
-    privateKeyToBytes(params: PrivateKeyToBytesInput): Promise<Uint8Array>;
-}
-/**
- * `AsymmetricKeyConverter` interface extends {@link KeyConverter |`KeyConverter`}, adding support
- * for public key conversions.
- */
-export interface AsymmetricKeyConverter<BytesToPublicKeyInput, PublicKeyToBytesInput> {
-    /**
-     * Converts a public key from a byte array to JWK format.
-     *
-     * @param params - The parameters for the public key conversion.
-     * @param params.publicKeyBytes - The raw public key as a Uint8Array.
-     *
-     * @returns A Promise that resolves to the public key in JWK format.
-     */
-    bytesToPublicKey(params: BytesToPublicKeyInput): Promise<Jwk>;
-    /**
-     * Converts a public key from JWK format to a byte array.
-     *
-     * @param params - The parameters for the public key conversion.
-     * @param params.publicKey - The public key in JWK format.
-     *
-     * @returns A Promise that resolves to the public key as a Uint8Array.
-     */
-    publicKeyToBytes(params: PublicKeyToBytesInput): Promise<Uint8Array>;
-}
-//# sourceMappingURL=key-converter.d.ts.map

package/dist/types/prototyping/crypto/types/key-converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-converter.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/types/key-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEzC;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,sBAAsB,EAAE,sBAAsB;IAE1E;;;;;;;OAOG;IACH,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAEhE;;;;;;;OAOG;IACH,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACxE;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB,CAAC,qBAAqB,EAAE,qBAAqB;IAClF;;;;;;;OAOG;IACH,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAE9D;;;;;;;OAOG;IACH,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACtE"}

package/dist/types/prototyping/crypto/types/key-deriver.d.ts

@@ -1,50 +0,0 @@
-/**
- * The `KeyDeriver` interface provide a method for key derivation.
- *
- * The `deriveKey()` method derives a {@link Jwk | JWK} from input data using the specified key
- * derivation algorithm. This interface is designed to support various key derivation
- * algorithms, accommodating different input and output types.
- */
-export interface KeyDeriver<DeriveKeyInput, DeriveKeyOutput> {
-    /**
-     * Derives a cryptographic key in JWK format based on the provided input parameters.
-     *
-     * @remarks
-     * The `deriveKey()` method of the {@link KeyDeriver | `KeyDeriver`} interface is utilized to
-     * generate cryptographic keys for operations like encryption, decryption, or signing. The method
-     * takes in parameters tailored to the key derivation algorithm being used and returns a promise
-     * that resolves to the derived key.
-     *
-     * @param params - The parameters for the key derivation process, specific to the chosen
-     *                 algorithm.
-     *
-     * @returns A Promise resolving to the derived key in the specified output format.
-     */
-    deriveKey(params: DeriveKeyInput): Promise<DeriveKeyOutput>;
-}
-/**
- * The `KeyBytesDeriver` interface provide a method for deriving a byte array using a key derivation
- * algorithm.
- *
- * The `deriveKeyBytes()` method to derives cryptographic bits from input data using the specified
- * key derivation algorithm. This interface is designed to support various key derivation
- * algorithms, accommodating different input and output types.
- */
-export interface KeyBytesDeriver<DeriveKeyBytesInput, DeriveKeyBytesOutput> {
-    /**
-     * Generates a specified number of cryptographic bits from given input parameters.
-     *
-     * @remarks
-     * The `deriveKeyBytes()` method of the {@link KeyBytesDeriver | `KeyBytesDeriver`} interface is
-     * used to create cryptographic material such as initialization vectors or keys from various
-     * sources. The method takes in parameters specific to the chosen key derivation algorithm and
-     * outputs a promise that resolves to a `Uint8Array` containing the derived bits.
-     *
-     * @param params - The parameters for the key derivation process, specific to the chosen
-     *                 algorithm.
-     *
-     * @returns A Promise resolving to the derived bits in the specified format.
-     */
-    deriveKeyBytes(params: DeriveKeyBytesInput): Promise<DeriveKeyBytesOutput>;
-}
-//# sourceMappingURL=key-deriver.d.ts.map

package/dist/types/prototyping/crypto/types/key-deriver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-deriver.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/types/key-deriver.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,UAAU,CACzB,cAAc,EACd,eAAe;IAEf;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAC7D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe,CAC9B,mBAAmB,EACnB,oBAAoB;IAEpB;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAC5E"}

package/dist/types/prototyping/crypto/types/key-io.d.ts

@@ -1,49 +0,0 @@
-import type { Jwk } from '@enbox/crypto';
-/**
- * The `KeyExporter` interface provides a method for exporting cryptographic keys.
- */
-export interface KeyExporter<ExportKeyInput, ExportKeyOutput = Jwk> {
-    /**
-     * Exports a cryptographic key to an external JWK object.
-     *
-     * @remarks
-     * The `exportKey()` method of the {@link KeyImporterExporter | `KeyImporterExporter`} interface
-     * returns a cryptographic key in JWK format, facilitating interoperability and backup.
-     *
-     * @param params - The parameters for the key export operation.
-     *
-     * @returns A Promise resolving to the exported key in JWK format.
-     */
-    exportKey(params: ExportKeyInput): Promise<ExportKeyOutput>;
-}
-/**
- * The `KeyImporter` interface provides a method for importing cryptographic keys.
- */
-export interface KeyImporter<ImportKeyInput, ImportKeyOutput = void> {
-    /**
-     * Imports an external key in JWK format.
-     *
-     * @remarks
-     * The `importKey()` method of the {@link KeyImporterExporter | `KeyImporterExporter`} interface
-     * takes as input an external key in JWK format and typically returns a key identifier reference
-     * for the imported key.
-     *
-     * @param params - The parameters for the key import operation.
-     *
-     * @returns A Promise resolving to the key identifier of the imported key.
-     */
-    importKey(params: ImportKeyInput): Promise<ImportKeyOutput>;
-}
-export interface KeyDeleter<DeleteKeyInput> {
-    /**
-     * Deletes a cryptographic key.
-     *
-     * @remarks
-     * The `deleteKey()` method of the {@link KeyDeleter | `KeyDeleter`} interface deletes a cryptographic
-     * key from the key store.
-     *
-     * @param params - The parameters for the key deletion operation.
-     */
-    deleteKey(params: DeleteKeyInput): Promise<void>;
-}
-//# sourceMappingURL=key-io.d.ts.map

package/dist/types/prototyping/crypto/types/key-io.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-io.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/types/key-io.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEzC;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,cAAc,EAAE,eAAe,GAAG,GAAG;IAChE;;;;;;;;;;OAUG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAC7D;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,cAAc,EAAE,eAAe,GAAG,IAAI;IACjE;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,UAAU,CAAC,cAAc;IACxC;;;;;;;;OAQG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD"}

package/dist/types/prototyping/crypto/types/key-manager.d.ts

@@ -1,69 +0,0 @@
-import type { KeyIdentifier, KmsDigestParams, KmsGenerateKeyParams, KmsGetKeyUriParams, KmsGetPublicKeyParams, KmsSignParams, KmsVerifyParams } from '@enbox/crypto';
-import type { DsaApi } from './crypto-api.js';
-import type { KmsCipherParams } from './params-kms.js';
-export interface KeyManagerParams {
-    CipherInput?: unknown;
-    GenerateKeyInput?: unknown;
-    GenerateKeyOutput?: unknown;
-    GetPublicKeyInput?: unknown;
-    SignInput?: unknown;
-    VerifyInput?: unknown;
-}
-export interface DefaultKeyManagerParams {
-    CipherInput: KmsCipherParams;
-    GenerateKeyInput: KmsGenerateKeyParams;
-    GenerateKeyOutput: KeyIdentifier;
-    GetPublicKeyInput: KmsGetPublicKeyParams;
-    SignInput: KmsSignParams;
-    VerifyInput: KmsVerifyParams;
-}
-/**
- * The `KeyManager` interface integrates key generation and signing capabilities.
- *
- * Concrete implementations of this interface are intended to be used as a Key Management System
- * (KMS), which is responsible for generating and storing cryptographic keys. The KMS is also
- * responsible for performing cryptographic operations using the keys it manages. The KMS can be
- * a local software based KMS, a cloud service, or a hardware device.
- *
- * Guidelines for implementing this interface:
- * - Must use JSON Web Keys ({@link Jwk | JWK}) as the key format.
- * - Must IANA registered JSON Object Signing and Encryption
- *   {@ link https://www.iana.org/assignments/jose/jose.xhtml#web-signature-encryption-algorithms | (JOSE)}
- *   names for algorithm, curves, etc. whenever possible.
- * - All I/O that interacts with private or secret keys must be done via reference using a
- *   {@link KeyIdentifier | `KeyIdentifier`}. Implementations can use any string as the key
- *   identifier (e.g. JWK thumbprint, UUID generated by hosted KMS, etc.).
- * - Must support key generation an signing operations.
- * - May be extended to support other cryptographic operations.
- * - Implementations of the `CryptoApi` interface can be passed as an argument to the public API
- *   methods of Web5 libraries that involve key material (e.g., DID creation, VC signing, arbitrary
- *   data signing/verification, etc.).
- *
- * @example
- * ```ts
- * // Example of using the KeyManager interface with default types
- * class DefaultKeyManager implements KeyManager {} // Uses default types
- *
- * // Example of using the KeyManager interface with custom types
- * class CustomKeyManager implements KeyManager<{
- *   GenerateKeyInput: CustomGenerateKeyParams, // Custom type
- *   KmsGetPublicKeyParams: CustomGetPublicKeyParams, // Custom type
- *   KmsSignParams: CustomSignParams, // Custom type
- *   // Omitting KmsVerifyParams to use the default
- * }> {
- *   // Implementation here
- * }
- * ```
- *
- * @typeParam T - The type of the key manager parameters.
- */
-export interface KeyManager<T extends KeyManagerParams = DefaultKeyManagerParams> extends DsaApi<T['GenerateKeyInput'], T['GenerateKeyOutput'], T['GetPublicKeyInput'], KmsDigestParams, T['SignInput'], T['VerifyInput']> {
-    /**
-     *
-     * @param params - The parameters for getting the key URI.
-     * @param params.key - The key to get the URI for.
-     * @returns The key URI.
-     */
-    getKeyUri(params: KmsGetKeyUriParams): Promise<KeyIdentifier>;
-}
-//# sourceMappingURL=key-manager.d.ts.map

package/dist/types/prototyping/crypto/types/key-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-manager.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/types/key-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,eAAe,EAChB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,eAAe,CAAC;IAC7B,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,iBAAiB,EAAE,aAAa,CAAC;IACjC,iBAAiB,EAAE,qBAAqB,CAAC;IACzC,SAAS,EAAE,aAAa,CAAC;IACzB,WAAW,EAAE,eAAe,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,gBAAgB,GAAG,uBAAuB,CAC9E,SAAQ,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC,mBAAmB,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC;IAExI;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC/D"}

package/dist/types/prototyping/crypto/types/params-direct.d.ts

@@ -1,75 +0,0 @@
-import type { Jwk } from '@enbox/crypto';
-export interface BytesToPrivateKeyParams {
-    algorithm: AlgorithmIdentifier;
-    privateKeyBytes: Uint8Array;
-}
-export interface BytesToPublicKeyParams {
-    algorithm: AlgorithmIdentifier;
-    publicKeyBytes: Uint8Array;
-}
-/**
- * Parameters for encryption and decryption operations.
- *
- * Intended for use with a Key Management System.
- */
-export interface CipherParams {
-    /** A {@link Jwk} containing the key to be used for encryption or decryption. */
-    key: Jwk;
-    /** Data to be encrypted or decrypted. */
-    data: Uint8Array;
-    /** Additional algorithm-specific parameters for encryption or decryption. */
-    [key: string]: unknown;
-}
-/**
- * Parameters for derivation of cryptographic keys.
- */
-export interface DeriveKeyParams {
-    /** The algorithm identifier. */
-    algorithm: AlgorithmIdentifier;
-    /** The base key to be used for derivation as a byte array. */
-    baseKeyBytes: Uint8Array;
-    /** The algorithm identifier for the derived key. */
-    derivedKeyAlgorithm?: AlgorithmIdentifier;
-    /** Additional algorithm-specific parameters for key derivation. */
-    [key: string]: unknown;
-}
-/**
- * Parameters for derivation of cryptographic byte arrays.
- */
-export interface DeriveKeyBytesParams {
-    /** The base key to be used for derivation as a byte array. */
-    baseKeyBytes: Uint8Array;
-    /** The desired length of the derived key in bits. */
-    length: number;
-}
-export interface PrivateKeyToBytesParams {
-    privateKey: Jwk;
-}
-export interface PublicKeyToBytesParams {
-    publicKey: Jwk;
-}
-/**
- * Parameters for wrapping a key.
- */
-export interface WrapKeyParams {
-    /** A {@link Jwk} containing the key used to encrypt the unwrapped key. */
-    encryptionKey: Jwk;
-    /** A {@link Jwk} containing the private key to be wrapped. */
-    unwrappedKey: Jwk;
-    /** An object defining the algorithm-specific parameters for encrypting the `unwrappedKey`. */
-    encryptParams?: unknown;
-}
-/**
- * Parameters for unwrapping a key.
- */
-export interface UnwrapKeyParams {
-    /** A {@link Jwk} containing the key used to decrypt the unwrapped key. */
-    decryptionKey: Jwk;
-    /** The wrapped private key as a byte array. */
-    wrappedKeyBytes: Uint8Array;
-    /** The algorithm identifier of the key encrypted in `wrappedKeyBytes`. */
-    wrappedKeyAlgorithm: string;
-    /** An object defining the algorithm-specific parameters for decrypting the `wrappedKeyBytes`. */
-    decryptParams?: unknown;
-}
-//# sourceMappingURL=params-direct.d.ts.map

package/dist/types/prototyping/crypto/types/params-direct.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"params-direct.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/types/params-direct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,eAAe,EAAE,UAAU,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,cAAc,EAAE,UAAU,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,GAAG,EAAE,GAAG,CAAC;IAET,yCAAyC;IACzC,IAAI,EAAE,UAAU,CAAC;IAEjB,6EAA6E;IAC7E,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,SAAS,EAAE,mBAAmB,CAAC;IAE/B,8DAA8D;IAC9D,YAAY,EAAE,UAAU,CAAC;IAEzB,oDAAoD;IACpD,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAE1C,mEAAmE;IACnE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,YAAY,EAAE,UAAU,CAAC;IAEzB,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,GAAG,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,GAAG,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,aAAa,EAAE,GAAG,CAAC;IAEnB,8DAA8D;IAC9D,YAAY,EAAE,GAAG,CAAC;IAElB,8FAA8F;IAC9F,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,aAAa,EAAE,GAAG,CAAC;IAEnB,+CAA+C;IAC/C,eAAe,EAAE,UAAU,CAAC;IAE5B,0EAA0E;IAC1E,mBAAmB,EAAE,MAAM,CAAC;IAE5B,iGAAiG;IACjG,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB"}