@enbox/agent 0.0.1

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

@@ -0,0 +1,45 @@
+import type { RecordsReadReply, UnionMessageReply, MessageSubscriptionHandler, RecordSubscriptionHandler } from '@enbox/dwn-sdk-js';
+export interface SerializableDwnMessage {
+    toJSON(): string;
+}
+export type DwnSubscriptionHandler = MessageSubscriptionHandler | RecordSubscriptionHandler;
+/**
+ * Interface for communicating with {@link https://github.com/TBD54566975/dwn-server | DWN Servers}
+ * via JSON-RPC, supporting operations like sending DWN requests.
+ */
+export interface DwnRpc {
+    /**
+     * Lists the transport protocols supported by the DWN RPC client, such as HTTP or HTTPS.
+     * @returns An array of strings representing the supported transport protocols.
+     */
+    get transportProtocols(): string[];
+    /**
+     * Sends a request to a DWN Server using the specified DWN RPC request parameters.
+     *
+     * @param request - The DWN RPC request containing the URL, target DID, message, and optional data.
+     * @returns A promise that resolves to the response from the DWN server.
+     */
+    sendDwnRequest(request: DwnRpcRequest): Promise<DwnRpcResponse>;
+}
+/**
+ * Represents a JSON RPC request to a DWN server, including the URL, target DID, the message to be
+ * processed, and optional data.
+ */
+export type DwnRpcRequest = {
+    /** Optional data to be sent with the request. */
+    data?: any;
+    /** The URL of the DWN server to which the request is sent. */
+    dwnUrl: string;
+    /** The message to be processed by the DWN server, which can be a serializable DWN message. */
+    message: SerializableDwnMessage | any;
+    /** The DID of the target to which the message is addressed. */
+    targetDid: string;
+    /** Optional subscription handler for DWN message events. */
+    subscriptionHandler?: DwnSubscriptionHandler;
+};
+/**
+ * Represents the JSON RPC response from a DWN server to a request, combining the results of various
+ * DWN operations.
+ */
+export type DwnRpcResponse = UnionMessageReply & RecordsReadReply;
+//# sourceMappingURL=dwn-rpc-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dwn-rpc-types.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/dwn-rpc-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEpI,MAAM,WAAW,sBAAsB;IACrC,MAAM,IAAI,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,sBAAsB,GAAG,0BAA0B,GAAG,yBAAyB,CAAC;AAE5F;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAA;IAElC;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CAChE;AAGD;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,IAAI,CAAC,EAAE,GAAG,CAAC;IAEX,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IAEf,8FAA8F;IAC9F,OAAO,EAAE,sBAAsB,GAAG,GAAG,CAAC;IAEtC,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAElB,4DAA4D;IAC5D,mBAAmB,CAAC,EAAE,sBAAsB,CAAC;CAC9C,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,gBAAgB,CAAC"}

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

@@ -0,0 +1,57 @@
+import { DwnServerInfoCache, ServerInfo } from './server-info-types.js';
+/**
+ * Configuration parameters for creating an in-memory cache for DWN ServerInfo entries.
+ *
+ * Allows customization of the cache time-to-live (TTL) setting.
+ */
+export type DwnServerInfoCacheMemoryParams = {
+    /**
+     * Optional. The time-to-live for cache entries, expressed as a string (e.g., '1h', '15m').
+     * Determines how long a cache entry should remain valid before being considered expired.
+     *
+     * Defaults to '15m' if not specified.
+     */
+    ttl?: string;
+};
+export declare class DwnServerInfoCacheMemory implements DwnServerInfoCache {
+    private cache;
+    constructor({ ttl }?: DwnServerInfoCacheMemoryParams);
+    /**
+     * Retrieves a DWN ServerInfo entry from the cache.
+     *
+     * If the cached item has exceeded its TTL, it's scheduled for deletion and undefined is returned.
+     *
+     * @param dwnUrl - The DWN URL endpoint string used as the key for getting the entry.
+     * @returns The cached DWN ServerInfo entry or undefined if not found or expired.
+     */
+    get(dwnUrl: string): Promise<ServerInfo | undefined>;
+    /**
+     * Stores a DWN ServerInfo entry in the cache with a TTL.
+     *
+     * @param dwnUrl - The DWN URL endpoint string used as the key for storing the entry.
+     * @param value - The DWN ServerInfo entry to be cached.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    set(dwnUrl: string, value: ServerInfo): Promise<void>;
+    /**
+     * Deletes a DWN ServerInfo entry from the cache.
+     *
+     * @param dwnUrl - The DWN URL endpoint string used as the key for deletion.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    delete(dwnUrl: string): Promise<void>;
+    /**
+     * Clears all entries from the cache.
+     *
+     * @returns A promise that resolves when the operation is complete.
+     */
+    clear(): Promise<void>;
+    /**
+     * This method is a no-op but exists to be consistent with other DWN ServerInfo Cache
+     * implementations.
+     *
+     * @returns A promise that resolves immediately.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=dwn-server-info-cache-memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dwn-server-info-cache-memory.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/dwn-server-info-cache-memory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAExE;;;;GAIG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C;;;;;OAKG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAA;AAED,qBAAa,wBAAyB,YAAW,kBAAkB;IACjE,OAAO,CAAC,KAAK,CAA+B;gBAEhC,EAAE,GAAW,EAAE,GAAE,8BAAkC;IAI/D;;;;;;;OAOG;IACU,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAE,SAAS,CAAC;IAIhE;;;;;;OAMG;IACU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE;;;;;OAKG;IACU,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlD;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC;;;;;OAKG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAGpC"}

package/dist/types/prototyping/clients/http-dwn-rpc-client.d.ts

@@ -0,0 +1,13 @@
+import type { DwnRpc, DwnRpcRequest, DwnRpcResponse } from './dwn-rpc-types.js';
+import { DwnServerInfoCache, ServerInfo } from './server-info-types.js';
+/**
+ * HTTP client that can be used to communicate with Dwn Servers
+ */
+export declare class HttpDwnRpcClient implements DwnRpc {
+    private serverInfoCache;
+    constructor(serverInfoCache?: DwnServerInfoCache);
+    get transportProtocols(): string[];
+    sendDwnRequest(request: DwnRpcRequest): Promise<DwnRpcResponse>;
+    getServerInfo(dwnUrl: string): Promise<ServerInfo>;
+}
+//# sourceMappingURL=http-dwn-rpc-client.d.ts.map

package/dist/types/prototyping/clients/http-dwn-rpc-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-dwn-rpc-client.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/http-dwn-rpc-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIhF,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGxE;;GAEG;AACH,qBAAa,gBAAiB,YAAW,MAAM;IAC7C,OAAO,CAAC,eAAe,CAAqB;gBAChC,eAAe,CAAC,EAAE,kBAAkB;IAIhD,IAAI,kBAAkB,aAAkC;IAElD,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IA0D/D,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAgCzD"}

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

@@ -0,0 +1,43 @@
+import { JsonRpcRequest, JsonRpcResponse } from './json-rpc.js';
+export interface JsonRpcSocketOptions {
+    /** socket connection timeout in milliseconds */
+    connectTimeout?: number;
+    /** response timeout for rpc requests in milliseconds */
+    responseTimeout?: number;
+    /** optional connection close handler */
+    onclose?: () => void;
+    /** optional socket error handler */
+    onerror?: (error?: any) => void;
+}
+/**
+ * JSON RPC Socket Client for WebSocket request/response and long-running subscriptions.
+ *
+ * NOTE: This is temporarily copied over from https://github.com/TBD54566975/dwn-server/blob/main/src/json-rpc-socket.ts
+ * This was done in order to avoid taking a dependency on the `dwn-server`, until a future time when there will be a `clients` package.
+ */
+export declare class JsonRpcSocket {
+    private socket;
+    private responseTimeout;
+    private messageHandlers;
+    private constructor();
+    static connect(url: string, options?: JsonRpcSocketOptions): Promise<JsonRpcSocket>;
+    close(): void;
+    /**
+     * Sends a JSON-RPC request through the socket and waits for a single response.
+     */
+    request(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    /**
+     * Sends a JSON-RPC request through the socket and keeps a listener open to read associated responses as they arrive.
+     * Returns a close method to clean up the listener.
+     */
+    subscribe(request: JsonRpcRequest, listener: (response: JsonRpcResponse) => void): Promise<{
+        response: JsonRpcResponse;
+        close?: () => Promise<void>;
+    }>;
+    private closeSubscription;
+    /**
+     * Sends a JSON-RPC request through the socket. You must subscribe to a message listener separately to capture the response.
+     */
+    send(request: JsonRpcRequest): void;
+}
+//# sourceMappingURL=json-rpc-socket.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-rpc-socket.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/json-rpc-socket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,cAAc,EAAE,eAAe,EAA+C,MAAM,eAAe,CAAC;AAMxH,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,oCAAoC;IACpC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CACjC;AAED;;;;;GAKG;AACH,qBAAa,aAAa;IAGJ,OAAO,CAAC,MAAM;IAAuB,OAAO,CAAC,eAAe;IAFhF,OAAO,CAAC,eAAe,CAA6D;IAEpF,OAAO;WAEM,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IA4C7F,KAAK,IAAI,IAAI;IAIb;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAyBhE;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GAAG,OAAO,CAAC;QAC/F,QAAQ,EAAE,eAAe,CAAC;QAC1B,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;KAC5B,CAAC;IA2CH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,cAAc,GAAE,IAAI;CAGnC"}

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

@@ -0,0 +1,49 @@
+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,
+    Unauthorized = -50401,
+    Forbidden = -50403,
+    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

@@ -0,0 +1 @@
+{"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;IACnB,YAAY,SAAS;IACrB,SAAS,SAAS;IAClB,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

@@ -0,0 +1,20 @@
+import { 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

@@ -0,0 +1 @@
+{"version":3,"file":"server-info-types.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/server-info-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,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,CAAA;AAED,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

@@ -0,0 +1,10 @@
+import type { DwnRpc, DwnRpcRequest, DwnRpcResponse } from './dwn-rpc-types.js';
+import { JsonRpcSocketOptions } from './json-rpc-socket.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

@@ -0,0 +1 @@
+{"version":3,"file":"web-socket-clients.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/clients/web-socket-clients.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAA0B,MAAM,oBAAoB,CAAC;AAKxG,OAAO,EAAiB,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAO3E,qBAAa,qBAAsB,YAAW,MAAM;IAClD,IAAW,kBAAkB,aAA8B;IAE3D,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;CAqCzC"}

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,151 @@
+import type { Jwk, Cipher, KeyConverter, KeyGenerator, DecryptParams, EncryptParams, GenerateKeyParams } from '@enbox/crypto';
+import { AES_GCM_TAG_LENGTHS, 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

@@ -0,0 +1 @@
+{"version":3,"file":"aes-gcm.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/aes-gcm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,GAAG,EACH,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAU,mBAAmB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE7E,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

@@ -0,0 +1,109 @@
+import type { GenerateKeyParams, Jwk, KeyConverter, KeyGenerator, KeyWrapper } from '@enbox/crypto';
+import { CryptoAlgorithm } from '@enbox/crypto';
+import type { BytesToPrivateKeyParams, PrivateKeyToBytesParams, UnwrapKeyParams, WrapKeyParams } from '../types/params-direct.js';
+import { RequireOnly } from '@enbox/common';
+/**
+ * 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

@@ -0,0 +1 @@
+{"version":3,"file":"aes-kw.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/aes-kw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpG,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAGlI,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;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"}