@enbox/agent 0.1.2 → 0.1.4

package/dist/types/prototyping/clients/json-rpc.d.ts

@@ -1,49 +0,0 @@
-export type JsonRpcId = string | number | null;
-export type JsonRpcParams = any;
-export type JsonRpcVersion = '2.0';
-export interface JsonRpcRequest {
-    jsonrpc: JsonRpcVersion;
-    id?: JsonRpcId;
-    /** JSON RPC Subscription Extension Parameters */
-    subscription?: {
-        id: JsonRpcId;
-    };
-    method: string;
-    params?: any;
-}
-export interface JsonRpcError {
-    code: JsonRpcErrorCodes;
-    message: string;
-    data?: any;
-}
-export declare enum JsonRpcErrorCodes {
-    InvalidRequest = -32600,
-    MethodNotFound = -32601,
-    InvalidParams = -32602,
-    InternalError = -32603,
-    ParseError = -32700,
-    TransportError = -32300,
-    BadRequest = -50400,// equivalent to HTTP Status 400
-    Unauthorized = -50401,// equivalent to HTTP Status 401
-    Forbidden = -50403,// equivalent to HTTP Status 403,
-    Conflict = -50409
-}
-export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
-export interface JsonRpcSuccessResponse {
-    jsonrpc: JsonRpcVersion;
-    id: JsonRpcId;
-    result: any;
-    error?: never;
-}
-export interface JsonRpcErrorResponse {
-    jsonrpc: JsonRpcVersion;
-    id: JsonRpcId;
-    result?: never;
-    error: JsonRpcError;
-}
-export declare const createJsonRpcErrorResponse: (id: JsonRpcId, code: JsonRpcErrorCodes, message: string, data?: any) => JsonRpcErrorResponse;
-export declare const createJsonRpcRequest: (id: JsonRpcId, method: string, params?: JsonRpcParams) => JsonRpcRequest;
-export declare const createJsonRpcSubscriptionRequest: (id: JsonRpcId, method: string, subscriptionId: JsonRpcId, params?: any) => JsonRpcRequest;
-export declare const createJsonRpcSuccessResponse: (id: JsonRpcId, result: any) => JsonRpcSuccessResponse;
-export declare function parseJson(text: string): object | null;
-//# sourceMappingURL=json-rpc.d.ts.map

package/dist/types/prototyping/clients/json-rpc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-rpc.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/json-rpc.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAC/C,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC;AAChC,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC;AAEnC,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,iDAAiD;IACjD,YAAY,CAAC,EAAE;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE,CAAA;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,oBAAY,iBAAiB;IAE3B,cAAc,SAAS;IACvB,cAAc,SAAS;IACvB,aAAa,SAAS;IACtB,aAAa,SAAS;IACtB,UAAU,SAAS;IACnB,cAAc,SAAS;IAGvB,UAAU,SAAS,CAAE,gCAAgC;IACrD,YAAY,SAAS,CAAE,gCAAgC;IACvD,SAAS,SAAS,CAAE,iCAAiC;IACrD,QAAQ,SAAS;CAClB;AAED,MAAM,MAAM,eAAe,GAAG,sBAAsB,GAAG,oBAAoB,CAAC;AAE5E,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,cAAc,CAAC;IACxB,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,cAAc,CAAC;IACxB,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,eAAO,MAAM,0BAA0B,OACjC,SAAS,QACP,iBAAiB,WACd,MAAM,SACR,GAAG,KACT,oBAOF,CAAC;AAEF,eAAO,MAAM,oBAAoB,OAC3B,SAAS,UACL,MAAM,WACL,aAAa,KACrB,cAOF,CAAC;AAEF,eAAO,MAAM,gCAAgC,OACvC,SAAS,UACL,MAAM,kBACE,SAAS,WAChB,GAAG,KACX,cAUF,CAAC;AAEF,eAAO,MAAM,4BAA4B,OACnC,SAAS,UACL,GAAG,KACV,sBAMF,CAAC;AAEF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMrD"}

package/dist/types/prototyping/clients/server-info-types.d.ts

@@ -1,20 +0,0 @@
-import type { KeyValueStore } from '@enbox/common';
-export type ServerInfo = {
-    /** the maximum file size the user can request to store */
-    maxFileSize: number;
-    /**
-     * an array of strings representing the server's registration requirements.
-     *
-     * ie. ['proof-of-work-sha256-v0', 'terms-of-service']
-     * */
-    registrationRequirements: string[];
-    /** whether web socket support is enabled on this server */
-    webSocketSupport: boolean;
-};
-export interface DwnServerInfoCache extends KeyValueStore<string, ServerInfo | undefined> {
-}
-export interface DwnServerInfoRpc {
-    /** retrieves the DWN Sever info, used to detect features such as WebSocket Subscriptions */
-    getServerInfo(url: string): Promise<ServerInfo>;
-}
-//# sourceMappingURL=server-info-types.d.ts.map

package/dist/types/prototyping/clients/server-info-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server-info-types.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/server-info-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG;IACvB,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;SAIK;IACL,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,2DAA2D;IAC3D,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,WAAW,kBAAmB,SAAQ,aAAa,CAAC,MAAM,EAAE,UAAU,GAAE,SAAS,CAAC;CAAG;AAE3F,MAAM,WAAW,gBAAgB;IAC/B,4FAA4F;IAC5F,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACjD"}

package/dist/types/prototyping/clients/web-socket-clients.d.ts

@@ -1,10 +0,0 @@
-import type { JsonRpcSocketOptions } from './json-rpc-socket.js';
-import type { DwnRpc, DwnRpcRequest, DwnRpcResponse } from './dwn-rpc-types.js';
-export declare class WebSocketDwnRpcClient implements DwnRpc {
-    get transportProtocols(): string[];
-    private static connections;
-    sendDwnRequest(request: DwnRpcRequest, jsonRpcSocketOptions?: JsonRpcSocketOptions): Promise<DwnRpcResponse>;
-    private static processMessage;
-    private static subscriptionRequest;
-}
-//# sourceMappingURL=web-socket-clients.d.ts.map

package/dist/types/prototyping/clients/web-socket-clients.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-socket-clients.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/web-socket-clients.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAA0B,MAAM,oBAAoB,CAAC;AAYxG,qBAAa,qBAAsB,YAAW,MAAM;IAClD,IAAW,kBAAkB,IAAI,MAAM,EAAE,CAA4B;IAErE,OAAO,CAAC,MAAM,CAAC,WAAW,CAAuC;IAE3D,cAAc,CAAC,OAAO,EAAE,aAAa,EAAE,oBAAoB,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC;mBA8B7F,cAAc;mBAed,mBAAmB;CAuCzC"}

package/dist/types/prototyping/common/object.d.ts

@@ -1,2 +0,0 @@
-export declare function hasDuplicateProperties(...objects: Array<Record<string, any> | undefined>): boolean;
-//# sourceMappingURL=object.d.ts.map

package/dist/types/prototyping/common/object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/common/object.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,OAAO,CAclG"}

package/dist/types/prototyping/common/type-utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Infer the type of a type parameter.
- *
- * This is useful when you want to infer the type of a type parameter in a generic function.
- */
-export type InferType<T> = T extends infer U ? U : never;
-//# sourceMappingURL=type-utils.d.ts.map

package/dist/types/prototyping/common/type-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/common/type-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/types/prototyping/crypto/algorithms/aes-gcm.d.ts

@@ -1,151 +0,0 @@
-import type { AES_GCM_TAG_LENGTHS, Cipher, DecryptParams, EncryptParams, GenerateKeyParams, Jwk, KeyConverter, KeyGenerator } from '@enbox/crypto';
-import { CryptoAlgorithm } from '@enbox/crypto';
-import type { BytesToPrivateKeyParams, PrivateKeyToBytesParams } from '../types/params-direct.js';
-/**
- * The `AesGcmGenerateKeyParams` interface defines the algorithm-specific parameters that should be
- * passed into the `generateKey()` method when using the AES-GCM algorithm.
- */
-export interface AesGcmGenerateKeyParams extends GenerateKeyParams {
-    /** Specifies the algorithm variant for key generation in AES-GCM mode.
-     * The value determines the length of the key to be generated and must be one of the following:
-     * - `"A128GCM"`: Generates a 128-bit key.
-     * - `"A192GCM"`: Generates a 192-bit key.
-     * - `"A256GCM"`: Generates a 256-bit key.
-     */
-    algorithm: 'A128GCM' | 'A192GCM' | 'A256GCM';
-}
-/**
- * The `AesGcmParams` interface defines the algorithm-specific parameters that should be passed
- * into the `encrypt()` and `decrypt()` methods when using the AES-GCM algorithm.
- */
-export interface AesGcmParams {
-    /**
-     * The `additionalData` property is used for authentication alongside encrypted data but isn't
-     * encrypted itself. It must match in both encryption and decryption; a mismatch will cause
-     * decryption to fail. This feature allows for the authentication of data without encrypting it.
-     *
-     * The `additionalData` property is optional and omitting it does not compromise encryption
-     * security.
-     */
-    additionalData?: Uint8Array;
-    /**
-     * The initialization vector (IV) must be unique for every encryption operation carried out with a
-     * given key. The IV need not be secret, but it must be unpredictable: that is, the IV must not be
-     * reused with the same key. The IV must be 12 bytes (96 bits) in length in accordance with the
-     * AES-GCM specification recommendedation to promote interoperability and efficiency.
-     *
-     * Note: It is OK to transmit the IV in the clear with the encrypted message.
-     */
-    iv: Uint8Array;
-    /**
-     * This property determines the size in bits of the authentication tag generated in the encryption
-     * operation and used for authentication in the corresponding decryption. In accordance with the
-     * AES-GCM specification, the tag length must be 96, 104, 112, 120 or 128.
-     *
-     * The `tagLength` property is optional and defaults to 128 bits if omitted.
-     */
-    tagLength?: typeof AES_GCM_TAG_LENGTHS[number];
-}
-/**
- * The `AesGcmAlgorithm` class provides a concrete implementation for cryptographic operations using
- * the AES algorithm in Galois/Counter Mode (GCM). This class implements both
- * {@link Cipher | `Cipher`} and { @link KeyGenerator | `KeyGenerator`} interfaces, providing
- * key generation, encryption, and decryption features.
- *
- * This class is typically accessed through implementations that extend the
- * {@link CryptoApi | `CryptoApi`} interface.
- */
-export declare class AesGcmAlgorithm extends CryptoAlgorithm implements Cipher<AesGcmParams, AesGcmParams>, KeyConverter, KeyGenerator<AesGcmGenerateKeyParams, Jwk> {
-    bytesToPrivateKey({ privateKeyBytes }: BytesToPrivateKeyParams): Promise<Jwk>;
-    /**
-     * Decrypts the provided data using AES-GCM.
-     *
-     * @remarks
-     * This method performs AES-GCM decryption on the given encrypted data using the specified key.
-     * It requires an initialization vector (IV), the encrypted data along with the decryption key,
-     * and optionally, additional authenticated data (AAD). The method returns the decrypted data as a
-     * Uint8Array. The optional `tagLength` parameter specifies the size in bits of the authentication
-     * tag used when encrypting the data. If not specified, the default tag length of 128 bits is
-     * used.
-     *
-     * @example
-     * ```ts
-     * const aesGcm = new AesGcmAlgorithm();
-     * const encryptedData = new Uint8Array([...]); // Encrypted data
-     * const iv = new Uint8Array([...]); // Initialization vector used during encryption
-     * const additionalData = new Uint8Array([...]); // Optional additional authenticated data
-     * const key = { ... }; // A Jwk object representing the AES key
-     * const decryptedData = await aesGcm.decrypt({
-     *   data: encryptedData,
-     *   iv,
-     *   additionalData,
-     *   key,
-     *   tagLength: 128 // Optional tag length in bits
-     * });
-     * ```
-     *
-     * @param params - The parameters for the decryption operation.
-     *
-     * @returns A Promise that resolves to the decrypted data as a Uint8Array.
-     */
-    decrypt(params: DecryptParams & AesGcmParams): Promise<Uint8Array>;
-    /**
-     * Encrypts the provided data using AES-GCM.
-     *
-     * @remarks
-     * This method performs AES-GCM encryption on the given data using the specified key.
-     * It requires an initialization vector (IV), the encrypted data along with the decryption key,
-     * and optionally, additional authenticated data (AAD). The method returns the encrypted data as a
-     * Uint8Array. The optional `tagLength` parameter specifies the size in bits of the authentication
-     * tag generated in the encryption operation and used for authentication in the corresponding
-     * decryption. If not specified, the default tag length of 128 bits is used.
-     *
-     * @example
-     * ```ts
-     * const aesGcm = new AesGcmAlgorithm();
-     * const data = new TextEncoder().encode('Messsage');
-     * const iv = new Uint8Array([...]); // Initialization vector
-     * const additionalData = new Uint8Array([...]); // Optional additional authenticated data
-     * const key = { ... }; // A Jwk object representing an AES key
-     * const encryptedData = await aesGcm.encrypt({
-     *   data,
-     *   iv,
-     *   additionalData,
-     *   key,
-     *   tagLength: 128 // Optional tag length in bits
-     * });
-     * ```
-     *
-     * @param params - The parameters for the encryption operation.
-     *
-     * @returns A Promise that resolves to the encrypted data as a Uint8Array.
-     */
-    encrypt(params: EncryptParams & AesGcmParams): Promise<Uint8Array>;
-    /**
-     * Generates a symmetric key for AES in Galois/Counter Mode (GCM) in JSON Web Key (JWK) format.
-     *
-     * @remarks
-     * This method generates a symmetric AES key for use in GCM mode, based on the specified
-     * `algorithm` parameter which determines the key length. It uses cryptographically secure random
-     * number generation to ensure the uniqueness and security of the key. The key is returned in JWK
-     * format.
-     *
-     * The generated key includes the following components:
-     * - `kty`: Key Type, set to 'oct' for Octet Sequence.
-     * - `k`: The symmetric key component, base64url-encoded.
-     * - `kid`: Key ID, generated based on the JWK thumbprint.
-     *
-     * @example
-     * ```ts
-     * const aesGcm = new AesGcmAlgorithm();
-     * const privateKey = await aesGcm.generateKey({ algorithm: 'A256GCM' });
-     * ```
-     *
-     * @param params - The parameters for the key generation.
-     *
-     * @returns A Promise that resolves to the generated symmetric key in JWK format.
-     */
-    generateKey({ algorithm }: AesGcmGenerateKeyParams): Promise<Jwk>;
-    privateKeyToBytes({ privateKey }: PrivateKeyToBytesParams): Promise<Uint8Array>;
-}
-//# sourceMappingURL=aes-gcm.d.ts.map

package/dist/types/prototyping/crypto/algorithms/aes-gcm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-gcm.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/aes-gcm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,GAAG,EACH,YAAY,EACZ,YAAY,EAAE,MAAM,eAAe,CAAC;AAEtC,OAAO,EAAU,eAAe,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAElG;;;GAGG;AACH,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE;;;;;OAKG;IACH,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;CAC9C;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,UAAU,CAAC;IAE5B;;;;;;;OAOG;IACH,EAAE,EAAE,UAAU,CAAC;IAEf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;CAChD;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,eACnC,YAAW,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,EAClC,YAAY,EACZ,YAAY,CAAC,uBAAuB,EAAE,GAAG,CAAC;IAExC,iBAAiB,CAAC,EAAE,eAAe,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,GAAG,CAAC;IAU1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACU,OAAO,CAAC,MAAM,EACzB,aAAa,GAAG,YAAY,GAC3B,OAAO,CAAC,UAAU,CAAC;IAMtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACU,OAAO,CAAC,MAAM,EACzB,aAAa,GAAG,YAAY,GAC3B,OAAO,CAAC,UAAU,CAAC;IAMtB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,WAAW,CAAC,EAAE,SAAS,EAAE,EACpC,uBAAuB,GACtB,OAAO,CAAC,GAAG,CAAC;IAaF,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC;CAM7F"}

package/dist/types/prototyping/crypto/algorithms/aes-kw.d.ts

@@ -1,108 +0,0 @@
-import type { RequireOnly } from '@enbox/common';
-import type { BytesToPrivateKeyParams, GenerateKeyParams, Jwk, KeyConverter, KeyGenerator, KeyWrapper, PrivateKeyToBytesParams, UnwrapKeyParams, WrapKeyParams } from '@enbox/crypto';
-import { CryptoAlgorithm } from '@enbox/crypto';
-/**
- * The `AesKwGenerateKeyParams` interface defines the algorithm-specific parameters that should be
- * passed into the `generateKey()` method when using the AES-KW algorithm.
- */
-export interface AesKwGenerateKeyParams extends GenerateKeyParams {
-    /** Specifies the algorithm variant for key generation in AES-KW mode.
-     * The value determines the length of the key to be generated and must be one of the following:
-     * - `"A128KW"`: AES Key Wrap using a 128-bit key.
-     * - `"A192KW"`: AES Key Wrap using a 192-bit key.
-     * - `"A256KW"`: AES Key Wrap using a 256-bit key.
-     */
-    algorithm: 'A128KW' | 'A192KW' | 'A256KW';
-}
-/**
- * The `AesKwAlgorithm` class provides a concrete implementation for cryptographic operations using
- * the AES algorithm for key wrapping. This class implements both
- * {@link KeyGenerator | `KeyGenerator`} and {@link KeyWrapper | `KeyWrapper`} interfaces, providing
- * key generation, key wrapping, and key unwrapping features.
- *
- * This class is typically accessed through implementations that extend the
- * {@link CryptoApi | `CryptoApi`} interface.
- */
-export declare class AesKwAlgorithm extends CryptoAlgorithm implements KeyConverter, KeyGenerator<AesKwGenerateKeyParams, Jwk>, KeyWrapper<WrapKeyParams, UnwrapKeyParams> {
-    bytesToPrivateKey({ privateKeyBytes }: RequireOnly<BytesToPrivateKeyParams, 'privateKeyBytes'>): Promise<Jwk>;
-    /**
-     * Generates a symmetric key for AES for key wrapping in JSON Web Key (JWK) format.
-     *
-     * @remarks
-     * This method generates a symmetric AES key for use in key wrapping mode, based on the specified
-     * `algorithm` parameter which determines the key length. It uses cryptographically secure random
-     * number generation to ensure the uniqueness and security of the key. The key is returned in JWK
-     * format.
-     *
-     * The generated key includes the following components:
-     * - `kty`: Key Type, set to 'oct' for Octet Sequence.
-     * - `k`: The symmetric key component, base64url-encoded.
-     * - `kid`: Key ID, generated based on the JWK thumbprint.
-     * - `alg`: Algorithm, set to 'A128KW', 'A192KW', or 'A256KW' for AES Key Wrap with the
-     *   specified key length.
-     *
-     * @example
-     * ```ts
-     * const aesKw = new AesKwAlgorithm();
-     * const privateKey = await aesKw.generateKey({ algorithm: 'A256KW' });
-     * ```
-     *
-     * @param params - The parameters for the key generation.
-     *
-     * @returns A Promise that resolves to the generated symmetric key in JWK format.
-     */
-    generateKey({ algorithm }: AesKwGenerateKeyParams): Promise<Jwk>;
-    privateKeyToBytes({ privateKey }: PrivateKeyToBytesParams): Promise<Uint8Array>;
-    /**
-     * Decrypts a wrapped key using the AES Key Wrap algorithm.
-     *
-     * @remarks
-     * This method unwraps a previously wrapped cryptographic key using the AES Key Wrap algorithm.
-     * The wrapped key, provided as a byte array, is unwrapped using the decryption key specified in
-     * the parameters.
-     *
-     * This operation is useful for securely receiving keys transmitted over untrusted mediums. The
-     * method returns the unwrapped key as a JSON Web Key (JWK).
-     *
-     * @example
-     * ```ts
-     * const aesKw = new AesKwAlgorithm();
-     * const wrappedKeyBytes = new Uint8Array([...]); // Byte array of a wrapped AES-256 GCM key
-     * const decryptionKey = { ... }; // A Jwk object representing the AES unwrapping key
-     * const unwrappedKey = await aesKw.unwrapKey({
-     *   wrappedKeyBytes,
-     *   wrappedKeyAlgorithm: 'A256GCM',
-     *   decryptionKey
-     * });
-     * ```
-     *
-     * @param params - The parameters for the key unwrapping operation.
-     *
-     * @returns A Promise that resolves to the unwrapped key in JWK format.
-     */
-    unwrapKey(params: UnwrapKeyParams): Promise<Jwk>;
-    /**
-     * Encrypts a given key using the AES Key Wrap algorithm.
-     *
-     * @remarks
-     * This method wraps a given cryptographic key using the AES Key Wrap algorithm. The private key
-     * to be wrapped is provided in the form of a JSON Web Key (JWK).
-     *
-     * This operation is useful for securely transmitting keys over untrusted mediums. The method
-     * returns the wrapped key as a byte array.
-     *
-     * @example
-     * ```ts
-     * const aesKw = new AesKwAlgorithm();
-     * const unwrappedKey = { ... }; // A Jwk object representing the key to be wrapped
-     * const encryptionKey = { ... }; // A Jwk object representing the AES wrapping key
-     * const wrappedKeyBytes = await aesKw.wrapKey({ unwrappedKey, encryptionKey });
-     * ```
-     *
-     * @param params - The parameters for the key wrapping operation.
-     *
-     * @returns A Promise that resolves to the wrapped key as a Uint8Array.
-     */
-    wrapKey(params: WrapKeyParams): Promise<Uint8Array>;
-}
-//# sourceMappingURL=aes-kw.d.ts.map

package/dist/types/prototyping/crypto/algorithms/aes-kw.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-kw.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/aes-kw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,GAAG,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,uBAAuB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEtL,OAAO,EAAS,eAAe,EAAE,MAAM,eAAe,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D;;;;;OAKG;IACH,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,qBAAa,cAAe,SAAQ,eAClC,YAAW,YAAY,EACZ,YAAY,CAAC,sBAAsB,EAAE,GAAG,CAAC,EACzC,UAAU,CAAC,aAAa,EAAE,eAAe,CAAC;IAExC,iBAAiB,CAAC,EAAE,eAAe,EAAE,EAChD,WAAW,CAAC,uBAAuB,EAAE,iBAAiB,CAAC,GACtD,OAAO,CAAC,GAAG,CAAC;IAUf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,WAAW,CAAC,EAAE,SAAS,EAAE,EACpC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAaF,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAC3C,uBAAuB,GACtB,OAAO,CAAC,UAAU,CAAC;IAOtB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACU,SAAS,CAAC,MAAM,EAC3B,eAAe,GACd,OAAO,CAAC,GAAG,CAAC;IAMf;;;;;;;;;;;;;;;;;;;;;OAqBG;IACU,OAAO,CAAC,MAAM,EACzB,aAAa,GACZ,OAAO,CAAC,UAAU,CAAC;CAKvB"}

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

@@ -1,160 +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 `EcdsaGenerateKeyParams` interface defines the algorithm-specific parameters that should be
- * passed into the `generateKey()` method when using the ECDSA algorithm.
- */
-export interface EcdsaGenerateKeyParams extends GenerateKeyParams {
-    /**
-     * A string defining the type of key to generate. The value must be one of the following:
-     * - `"ES256"`: ECDSA using the secp256r1 (P-256) curve and SHA-256.
-     * - `"ES256K"`: ECDSA using the secp256k1 curve and SHA-256.
-     * - `"secp256k1"`: ECDSA using the secp256k1 curve and SHA-256.
-     * - `"secp256r1"`: ECDSA using the secp256r1 (P-256) curve and SHA-256.
-     */
-    algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1';
-}
-/**
- * The `EcdsaAlgorithm` class provides a concrete implementation for cryptographic operations using
- * the Elliptic Curve Digital Signature Algorithm (ECDSA). 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 EcdsaAlgorithm extends CryptoAlgorithm implements AsymmetricKeyGenerator<EcdsaGenerateKeyParams, Jwk, GetPublicKeyParams>, KeyConverter, AsymmetricKeyConverter, Signer<SignParams, VerifyParams> {
-    bytesToPrivateKey({ algorithm, privateKeyBytes }: BytesToPrivateKeyParams & {
-        algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1';
-    }): Promise<Jwk>;
-    bytesToPublicKey({ algorithm, publicKeyBytes }: BytesToPublicKeyParams & {
-        algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1';
-    }): 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 ecdsa = new EcdsaAlgorithm();
-     * const privateKey = { ... }; // A Jwk object representing a private key
-     * const publicKey = await ecdsa.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 ecdsa = new EcdsaAlgorithm();
-     * const privateKey = await ecdsa.generateKey({ algorithm: 'ES256K' });
-     * ```
-     *
-     * @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 }: EcdsaGenerateKeyParams): 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 ECDSA 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 200 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 ecdsa = new EcdsaAlgorithm();
-     * const privateKey = { ... }; // A Jwk object representing a private key
-     * const publicKey = await ecdsa.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 ECDSA 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 ecdsa = new EcdsaAlgorithm();
-     * const data = new TextEncoder().encode('Message');
-     * const privateKey = { ... }; // A Jwk object representing a private key
-     * const signature = await ecdsa.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 ECDSA 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 ecdsa = new EcdsaAlgorithm();
-     * 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 ecdsa.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=ecdsa.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/ecdsa.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,EAAuD,MAAM,eAAe,CAAC;AAErG,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAGlJ;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D;;;;;;OAMG;IACH,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC;CAC3D;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,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAA;KAAE,GACtF,OAAO,CAAC,GAAG,CAAC;IAuBF,gBAAgB,CAAC,EAAE,SAAS,EAAE,cAAc,EAAE,EACzD,sBAAsB,GAAG;QAAE,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAA;KAAE,GACrF,OAAO,CAAC,GAAG,CAAC;IAuBf;;;;;;;;;;;;;;;;;;;OAmBG;IACU,gBAAgB,CAAC,EAAE,GAAG,EAAE,EACnC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAuBf;;;;;;;;;;;;;OAaG;IACU,WAAW,CAAC,EAAE,SAAS,EAAE,EACpC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAmBf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,YAAY,CAAC,EAAE,GAAG,EAAE,EAC/B,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAuBF,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAC3C,uBAAuB,GACtB,OAAO,CAAC,UAAU,CAAC;IAiBT,gBAAgB,CAAC,EAAE,SAAS,EAAE,EACzC,sBAAsB,GACrB,OAAO,CAAC,UAAU,CAAC;IAiBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACU,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAC7B,UAAU,GACT,OAAO,CAAC,UAAU,CAAC;IAmBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACU,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAC1C,YAAY,GACX,OAAO,CAAC,OAAO,CAAC;CAkBpB"}