@bandeira-tech/b3nd-web 0.2.0 → 0.2.2

package/dist/{chunk-C2ZIFM22.js → chunk-T43IWAQK.js}

@@ -1,15 +1,14 @@
 // clients/websocket/mod.ts
 var WebSocketClient = class {
-  config;
-  ws = null;
-  connected = false;
-  reconnectAttempts = 0;
-  reconnectTimer = null;
-  pendingRequests = /* @__PURE__ */ new Map();
-  messageHandler = this.handleMessage.bind(this);
-  closeHandler = this.handleClose.bind(this);
-  errorHandler = this.handleError.bind(this);
   constructor(config) {
+    this.ws = null;
+    this.connected = false;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.messageHandler = this.handleMessage.bind(this);
+    this.closeHandler = this.handleClose.bind(this);
+    this.errorHandler = this.handleError.bind(this);
     this.config = {
       timeout: 3e4,
       ...config,
@@ -26,19 +25,17 @@ var WebSocketClient = class {
    * Ensure WebSocket connection is established
    */
   async ensureConnected() {
-    var _a, _b;
-    if (this.connected && ((_a = this.ws) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
       return;
     }
-    if (((_b = this.ws) == null ? void 0 : _b.readyState) === WebSocket.CONNECTING) {
+    if (this.ws?.readyState === WebSocket.CONNECTING) {
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), this.config.timeout);
         const checkConnection = () => {
-          var _a2, _b2;
           if (this.connected) {
             clearTimeout(timeout);
             resolve();
-          } else if (((_a2 = this.ws) == null ? void 0 : _a2.readyState) === WebSocket.CLOSED || ((_b2 = this.ws) == null ? void 0 : _b2.readyState) === WebSocket.CLOSING) {
+          } else if (this.ws?.readyState === WebSocket.CLOSED || this.ws?.readyState === WebSocket.CLOSING) {
             clearTimeout(timeout);
             reject(new Error("Connection failed"));
           } else {
@@ -78,8 +75,7 @@ var WebSocketClient = class {
         this.ws.addEventListener("close", this.closeHandler);
         this.ws.addEventListener("error", this.errorHandler);
         const timeout = setTimeout(() => {
-          var _a;
-          (_a = this.ws) == null ? void 0 : _a.close();
+          this.ws?.close();
           reject(new Error("Connection timeout"));
         }, this.config.timeout);
         this.ws.addEventListener("open", () => clearTimeout(timeout), { once: true });
@@ -108,10 +104,9 @@ var WebSocketClient = class {
    * Handle WebSocket close
    */
   handleClose() {
-    var _a;
     this.connected = false;
     this.cleanupPendingRequests(new Error("WebSocket connection closed"));
-    if (((_a = this.config.reconnect) == null ? void 0 : _a.enabled) && this.reconnectAttempts < (this.config.reconnect.maxAttempts || 5)) {
+    if (this.config.reconnect?.enabled && this.reconnectAttempts < (this.config.reconnect.maxAttempts || 5)) {
       this.scheduleReconnect();
     }
   }
@@ -126,11 +121,10 @@ var WebSocketClient = class {
    * Schedule reconnection attempt
    */
   scheduleReconnect() {
-    var _a, _b;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
     }
-    const delay = ((_a = this.config.reconnect) == null ? void 0 : _a.backoff) === "exponential" ? (this.config.reconnect.interval || 1e3) * Math.pow(2, this.reconnectAttempts) : ((_b = this.config.reconnect) == null ? void 0 : _b.interval) || 1e3;
+    const delay = this.config.reconnect?.backoff === "exponential" ? (this.config.reconnect.interval || 1e3) * Math.pow(2, this.reconnectAttempts) : this.config.reconnect?.interval || 1e3;
     this.reconnectTimer = setTimeout(() => {
       this.reconnectAttempts++;
       this.connect().catch(() => {
@@ -153,7 +147,6 @@ var WebSocketClient = class {
   async sendRequest(type, payload) {
     await this.ensureConnected();
     return new Promise((resolve, reject) => {
-      var _a;
       const id = crypto.randomUUID();
       const request = { id, type, payload };
       const timeout = setTimeout(() => {
@@ -172,7 +165,7 @@ var WebSocketClient = class {
         timeout
       });
       try {
-        (_a = this.ws) == null ? void 0 : _a.send(JSON.stringify(request));
+        this.ws?.send(JSON.stringify(request));
       } catch (error) {
         this.pendingRequests.delete(id);
         clearTimeout(timeout);
@@ -211,8 +204,8 @@ var WebSocketClient = class {
         success: true,
         data: [],
         pagination: {
-          page: (options == null ? void 0 : options.page) || 1,
-          limit: (options == null ? void 0 : options.limit) || 50
+          page: options?.page || 1,
+          limit: options?.limit || 50
         }
       };
     }

package/dist/{chunk-QHDBFVLU.js → chunk-VAZUCGED.js}

@@ -1,15 +1,10 @@
 // apps/mod.ts
 var AppsClient = class {
-  base;
-  api;
-  f;
-  authToken;
   constructor(cfg) {
     if (!cfg.appServerUrl) throw new Error("appServerUrl is required");
     if (!cfg.apiBasePath) throw new Error("apiBasePath is required");
     this.base = cfg.appServerUrl.replace(/\/$/, "");
     this.api = (cfg.apiBasePath.startsWith("/") ? cfg.apiBasePath : `/${cfg.apiBasePath}`).replace(/\/$/, "");
-    if (cfg.authToken) this.authToken = cfg.authToken;
     if (cfg.fetch) {
       this.f = cfg.fetch;
     } else if (typeof window !== "undefined" && typeof window.fetch === "function") {
@@ -18,55 +13,62 @@ var AppsClient = class {
       this.f = fetch;
     }
   }
-  setAuthToken(token) {
-    this.authToken = token;
-  }
   async health() {
     const r = await this.f(`${this.base}${this.api}/health`);
     if (!r.ok) throw new Error(`health failed: ${r.statusText}`);
     return r.json();
   }
-  async registerApp(reg) {
-    const r = await this.f(`${this.base}${this.api}/apps/register`, {
+  async updateOrigins(appKey, message) {
+    const r = await this.f(`${this.base}${this.api}/apps/origins/${encodeURIComponent(appKey)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async updateGoogleClientId(appKey, message) {
+    const r = await this.f(`${this.base}${this.api}/apps/google-client-id/${encodeURIComponent(appKey)}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} },
-      body: JSON.stringify(reg)
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
-  async updateSchema(appKey, actions) {
-    const r = await this.f(`${this.base}${this.api}/apps/${encodeURIComponent(appKey)}/schema`, {
+  async updateSchema(appKey, message) {
+    const r = await this.f(`${this.base}${this.api}/apps/schema/${encodeURIComponent(appKey)}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} },
-      body: JSON.stringify(actions)
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
   async getSchema(appKey) {
-    const r = await this.f(`${this.base}${this.api}/apps/${encodeURIComponent(appKey)}/schema`, { headers: { ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} } });
+    const r = await this.f(`${this.base}${this.api}/apps/schema/${encodeURIComponent(appKey)}`);
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
-  async createSession(appKey, token) {
+  async createSession(appKey, message) {
     const r = await this.f(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/session`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ token })
+      body: JSON.stringify(message)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
-  async invokeAction(appKey, action, payload, origin) {
+  async invokeAction(appKey, action, signedMessage, origin) {
     const r = await this.f(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/${encodeURIComponent(action)}`, {
       method: "POST",
-      headers: { "Content-Type": "text/plain", ...origin ? { Origin: origin } : {} },
-      body: payload
+      headers: { "Content-Type": "application/json", ...origin ? { Origin: origin } : {} },
+      body: JSON.stringify(signedMessage)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);

package/dist/clients/http/mod.d.ts

@@ -1,4 +1,4 @@
-import { N as NodeProtocolInterface, a as HttpClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-Bw0Boe0n.js';
+import { N as NodeProtocolInterface, a as HttpClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-oQCx3U-_.js';
 
 /**
  * HttpClient - HTTP implementation of NodeProtocolInterface

package/dist/clients/http/mod.js

@@ -1,6 +1,6 @@
 import {
   HttpClient
-} from "../../chunk-PMBS2GFA.js";
+} from "../../chunk-LFUC4ETD.js";
 import "../../chunk-MLKGABMK.js";
 export {
   HttpClient

package/dist/clients/local-storage/mod.d.ts

@@ -1,4 +1,4 @@
-import { N as NodeProtocolInterface, d as LocalStorageClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-Bw0Boe0n.js';
+import { N as NodeProtocolInterface, d as LocalStorageClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-oQCx3U-_.js';
 
 /**
  * LocalStorageClient - Browser localStorage implementation of NodeProtocolInterface

package/dist/clients/local-storage/mod.js

@@ -1,6 +1,6 @@
 import {
   LocalStorageClient
-} from "../../chunk-XH4OLKBV.js";
+} from "../../chunk-7U5JDFQW.js";
 import "../../chunk-MLKGABMK.js";
 export {
   LocalStorageClient

package/dist/clients/websocket/mod.d.ts

@@ -1,4 +1,4 @@
-import { N as NodeProtocolInterface, W as WebSocketClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-Bw0Boe0n.js';
+import { N as NodeProtocolInterface, W as WebSocketClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-oQCx3U-_.js';
 
 /**
  * WebSocketClient - WebSocket implementation of NodeProtocolInterface

package/dist/clients/websocket/mod.js

@@ -1,6 +1,6 @@
 import {
   WebSocketClient
-} from "../../chunk-C2ZIFM22.js";
+} from "../../chunk-T43IWAQK.js";
 import "../../chunk-MLKGABMK.js";
 export {
   WebSocketClient

package/dist/encrypt/mod.d.ts

@@ -1 +1 @@
-export { A as AuthenticatedMessage, a as EncryptedPayload, E as EncryptionKeyPair, K as KeyPair, S as SignedEncryptedMessage, h as createAuthenticatedMessage, i as createSignedEncryptedMessage, d as decrypt, f as decryptWithHex, e as encrypt, b as generateEncryptionKeyPair, k as generateNonce, l as generateRandomData, g as generateSigningKeyPair, s as sign, c as signWithHex, v as verify, j as verifyAndDecrypt } from '../mod-DHjjiF1o.js';
+export { A as AuthenticatedMessage, a as EncryptedPayload, E as EncryptionKeyPair, I as IdentityKey, K as KeyPair, d as PrivateEncryptionKey, P as PublicEncryptionKey, c as SecretEncryptionKey, S as SignedEncryptedMessage, b as SignedSymmetricMessage, k as createAuthenticatedMessage, l as createAuthenticatedMessageWithHex, w as createSignedEncryptedMessage, B as createSignedSymmetricMessage, i as decrypt, z as decryptSymmetric, j as decryptWithHex, n as deriveKeyFromSeed, h as encrypt, y as encryptSymmetric, r as exportPrivateKeyPem, e as generateEncryptionKeyPair, o as generateNonce, q as generateRandomData, g as generateSigningKeyPair, p as pemToCryptoKey, s as sign, t as signPayload, f as signWithHex, v as verify, x as verifyAndDecryptMessage, u as verifyPayload } from '../mod-D02790g_.js';

package/dist/encrypt/mod.js

@@ -1,31 +1,57 @@
 import {
+  IdentityKey,
+  PrivateEncryptionKey,
+  PublicEncryptionKey,
+  SecretEncryptionKey,
   createAuthenticatedMessage,
+  createAuthenticatedMessageWithHex,
   createSignedEncryptedMessage,
+  createSignedSymmetricMessage,
   decrypt,
+  decryptSymmetric,
   decryptWithHex,
+  deriveKeyFromSeed,
   encrypt,
+  encryptSymmetric,
+  exportPrivateKeyPem,
   generateEncryptionKeyPair,
   generateNonce,
   generateRandomData,
   generateSigningKeyPair,
+  pemToCryptoKey,
   sign,
+  signPayload,
   signWithHex,
   verify,
-  verifyAndDecrypt
-} from "../chunk-G6JDROB4.js";
+  verifyAndDecryptMessage,
+  verifyPayload
+} from "../chunk-K3ZSSVHR.js";
 import "../chunk-MLKGABMK.js";
 export {
+  IdentityKey,
+  PrivateEncryptionKey,
+  PublicEncryptionKey,
+  SecretEncryptionKey,
   createAuthenticatedMessage,
+  createAuthenticatedMessageWithHex,
   createSignedEncryptedMessage,
+  createSignedSymmetricMessage,
   decrypt,
+  decryptSymmetric,
   decryptWithHex,
+  deriveKeyFromSeed,
   encrypt,
+  encryptSymmetric,
+  exportPrivateKeyPem,
   generateEncryptionKeyPair,
   generateNonce,
   generateRandomData,
   generateSigningKeyPair,
+  pemToCryptoKey,
   sign,
+  signPayload,
   signWithHex,
   verify,
-  verifyAndDecrypt
+  verifyAndDecryptMessage,
+  verifyPayload
 };

package/dist/mod-D02790g_.d.ts

@@ -0,0 +1,241 @@
+interface KeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+    privateKeyHex: string;
+}
+interface EncryptionKeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}
+interface EncryptedPayload {
+    data: string;
+    nonce: string;
+    ephemeralPublicKey?: string;
+}
+interface AuthenticatedMessage<T = unknown> {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: T;
+}
+interface SignedEncryptedMessage {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: EncryptedPayload;
+}
+interface SignedSymmetricMessage {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: EncryptedPayload;
+}
+declare class IdentityKey {
+    private readonly privateKey;
+    readonly publicKeyHex: string;
+    private constructor();
+    static generate(): Promise<{
+        key: IdentityKey;
+        privateKeyPem: string;
+        publicKeyHex: string;
+    }>;
+    static fromPem(pem: string, publicKeyHex: string): Promise<IdentityKey>;
+    static fromHex(params: {
+        privateKeyHex: string;
+        publicKeyHex: string;
+    }): Promise<IdentityKey>;
+    sign(payload: unknown): Promise<string>;
+}
+declare class PublicEncryptionKey {
+    readonly publicKeyHex: string;
+    readonly publicKey: CryptoKey | null;
+    constructor(publicKeyHex: string, publicKey: CryptoKey | null);
+    static fromHex(publicKeyHex: string): Promise<PublicEncryptionKey>;
+    static generatePair(): Promise<{
+        publicKey: PublicEncryptionKey;
+        privateKeyHex: string;
+    }>;
+    encrypt(data: unknown): Promise<EncryptedPayload>;
+    toHex(): string;
+}
+declare class SecretEncryptionKey {
+    readonly keyHex: string;
+    private constructor();
+    static fromSecret(params: {
+        secret: string;
+        salt: string;
+        iterations?: number;
+    }): Promise<SecretEncryptionKey>;
+    static fromHex(keyHex: string): SecretEncryptionKey;
+    encrypt(data: unknown): Promise<EncryptedPayload>;
+    decrypt(payload: EncryptedPayload): Promise<unknown>;
+}
+declare class PrivateEncryptionKey {
+    readonly privateKey: CryptoKey;
+    readonly privateKeyHex: string;
+    readonly publicKeyHex: string;
+    constructor(privateKey: CryptoKey, privateKeyHex: string, publicKeyHex: string);
+    static fromHex(params: {
+        privateKeyHex: string;
+        publicKeyHex: string;
+    }): Promise<PrivateEncryptionKey>;
+    static generatePair(): Promise<{
+        privateKey: PrivateEncryptionKey;
+        publicKey: PublicEncryptionKey;
+    }>;
+    toPublic(): PublicEncryptionKey;
+    decrypt(payload: EncryptedPayload): Promise<unknown>;
+    toHex(): string;
+}
+/**
+ * Convert a PEM-encoded private key to a CryptoKey
+ */
+declare function pemToCryptoKey(pem: string, algorithm: "Ed25519" | "X25519"): Promise<CryptoKey>;
+/**
+ * Generate an Ed25519 keypair for signing
+ */
+declare function generateSigningKeyPair(): Promise<KeyPair>;
+/**
+ * Generate an X25519 keypair for encryption (ECDH)
+ */
+declare function generateEncryptionKeyPair(): Promise<EncryptionKeyPair>;
+/**
+ * Sign a payload with an Ed25519 private key
+ */
+declare function sign<T>(privateKey: CryptoKey, payload: T): Promise<string>;
+/**
+ * Sign a payload with an Ed25519 private key from hex
+ */
+declare function signWithHex<T>(privateKeyHex: string, payload: T): Promise<string>;
+/**
+ * Verify a signature using Ed25519 public key
+ */
+declare function verify<T>(publicKeyHex: string, signatureHex: string, payload: T): Promise<boolean>;
+/**
+ * Encrypt data using X25519 ECDH + AES-GCM
+ * Uses ephemeral keypair for forward secrecy
+ */
+declare function encrypt(data: unknown, recipientPublicKeyHex: string): Promise<EncryptedPayload>;
+/**
+ * Decrypt data using X25519 ECDH + AES-GCM
+ */
+declare function decrypt(encryptedPayload: EncryptedPayload, recipientPrivateKey: CryptoKey): Promise<unknown>;
+/**
+ * Decrypt data using private key from hex
+ */
+declare function decryptWithHex(encryptedPayload: EncryptedPayload, recipientPrivateKeyHex: string): Promise<unknown>;
+/**
+ * Create an authenticated message (signed but not encrypted)
+ */
+declare function createAuthenticatedMessage<T>(payload: T, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>): Promise<AuthenticatedMessage<T>>;
+/**
+ * Create an authenticated message with hex-encoded keys (convenience wrapper)
+ */
+declare function createAuthenticatedMessageWithHex<T>(payload: T, pubkeyHex: string, privateKeyHex: string): Promise<AuthenticatedMessage<T>>;
+/**
+ * Derive an encryption key from seed and salt using PBKDF2
+ * Returns hex-encoded key suitable for encrypt/decrypt functions
+ */
+declare function deriveKeyFromSeed(seed: string, salt: string, iterations?: number): Promise<string>;
+declare function generateNonce(length?: number): Uint8Array;
+declare function generateRandomData(size: number): Uint8Array;
+declare function exportPrivateKeyPem(privateKey: CryptoKey, label: string): Promise<string>;
+declare function signPayload(params: {
+    payload: unknown;
+    identity: IdentityKey;
+}): Promise<Array<{
+    pubkey: string;
+    signature: string;
+}>>;
+declare function verifyPayload(params: {
+    payload: unknown;
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+}): Promise<{
+    verified: boolean;
+    signers: string[];
+}>;
+declare function createSignedEncryptedMessage(params: {
+    data: unknown;
+    identity: IdentityKey;
+    encryptionKey: SecretEncryptionKey | PublicEncryptionKey;
+}): Promise<SignedEncryptedMessage>;
+declare function createSignedEncryptedMessage(data: unknown, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>, recipientPublicKeyHex: string): Promise<SignedEncryptedMessage>;
+declare function verifyAndDecryptMessage(params: {
+    message: SignedEncryptedMessage;
+    encryptionKey: SecretEncryptionKey | PrivateEncryptionKey;
+}): Promise<{
+    data: unknown;
+    verified: boolean;
+    signers: string[];
+}>;
+/**
+ * Encrypt data using a symmetric key (AES-GCM) provided as hex
+ */
+declare function encryptSymmetric(data: unknown, keyHex: string): Promise<EncryptedPayload>;
+/**
+ * Decrypt data using a symmetric key (AES-GCM) provided as hex
+ */
+declare function decryptSymmetric(payload: EncryptedPayload, keyHex: string): Promise<unknown>;
+/**
+ * Create a signed symmetric message (signs encrypted payload)
+ */
+declare function createSignedSymmetricMessage(data: unknown, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>, keyHex: string): Promise<SignedSymmetricMessage>;
+
+type mod_AuthenticatedMessage<T = unknown> = AuthenticatedMessage<T>;
+type mod_EncryptedPayload = EncryptedPayload;
+type mod_EncryptionKeyPair = EncryptionKeyPair;
+type mod_IdentityKey = IdentityKey;
+declare const mod_IdentityKey: typeof IdentityKey;
+type mod_KeyPair = KeyPair;
+type mod_PrivateEncryptionKey = PrivateEncryptionKey;
+declare const mod_PrivateEncryptionKey: typeof PrivateEncryptionKey;
+type mod_PublicEncryptionKey = PublicEncryptionKey;
+declare const mod_PublicEncryptionKey: typeof PublicEncryptionKey;
+type mod_SecretEncryptionKey = SecretEncryptionKey;
+declare const mod_SecretEncryptionKey: typeof SecretEncryptionKey;
+type mod_SignedEncryptedMessage = SignedEncryptedMessage;
+type mod_SignedSymmetricMessage = SignedSymmetricMessage;
+declare const mod_createAuthenticatedMessage: typeof createAuthenticatedMessage;
+declare const mod_createAuthenticatedMessageWithHex: typeof createAuthenticatedMessageWithHex;
+declare const mod_createSignedEncryptedMessage: typeof createSignedEncryptedMessage;
+declare const mod_createSignedSymmetricMessage: typeof createSignedSymmetricMessage;
+declare const mod_decrypt: typeof decrypt;
+declare const mod_decryptSymmetric: typeof decryptSymmetric;
+declare const mod_decryptWithHex: typeof decryptWithHex;
+declare const mod_deriveKeyFromSeed: typeof deriveKeyFromSeed;
+declare const mod_encrypt: typeof encrypt;
+declare const mod_encryptSymmetric: typeof encryptSymmetric;
+declare const mod_exportPrivateKeyPem: typeof exportPrivateKeyPem;
+declare const mod_generateEncryptionKeyPair: typeof generateEncryptionKeyPair;
+declare const mod_generateNonce: typeof generateNonce;
+declare const mod_generateRandomData: typeof generateRandomData;
+declare const mod_generateSigningKeyPair: typeof generateSigningKeyPair;
+declare const mod_pemToCryptoKey: typeof pemToCryptoKey;
+declare const mod_sign: typeof sign;
+declare const mod_signPayload: typeof signPayload;
+declare const mod_signWithHex: typeof signWithHex;
+declare const mod_verify: typeof verify;
+declare const mod_verifyAndDecryptMessage: typeof verifyAndDecryptMessage;
+declare const mod_verifyPayload: typeof verifyPayload;
+declare namespace mod {
+  export { type mod_AuthenticatedMessage as AuthenticatedMessage, type mod_EncryptedPayload as EncryptedPayload, type mod_EncryptionKeyPair as EncryptionKeyPair, mod_IdentityKey as IdentityKey, type mod_KeyPair as KeyPair, mod_PrivateEncryptionKey as PrivateEncryptionKey, mod_PublicEncryptionKey as PublicEncryptionKey, mod_SecretEncryptionKey as SecretEncryptionKey, type mod_SignedEncryptedMessage as SignedEncryptedMessage, type mod_SignedSymmetricMessage as SignedSymmetricMessage, mod_createAuthenticatedMessage as createAuthenticatedMessage, mod_createAuthenticatedMessageWithHex as createAuthenticatedMessageWithHex, mod_createSignedEncryptedMessage as createSignedEncryptedMessage, mod_createSignedSymmetricMessage as createSignedSymmetricMessage, mod_decrypt as decrypt, mod_decryptSymmetric as decryptSymmetric, mod_decryptWithHex as decryptWithHex, mod_deriveKeyFromSeed as deriveKeyFromSeed, mod_encrypt as encrypt, mod_encryptSymmetric as encryptSymmetric, mod_exportPrivateKeyPem as exportPrivateKeyPem, mod_generateEncryptionKeyPair as generateEncryptionKeyPair, mod_generateNonce as generateNonce, mod_generateRandomData as generateRandomData, mod_generateSigningKeyPair as generateSigningKeyPair, mod_pemToCryptoKey as pemToCryptoKey, mod_sign as sign, mod_signPayload as signPayload, mod_signWithHex as signWithHex, mod_verify as verify, mod_verifyAndDecryptMessage as verifyAndDecryptMessage, mod_verifyPayload as verifyPayload };
+}
+
+export { type AuthenticatedMessage as A, createSignedSymmetricMessage as B, type EncryptionKeyPair as E, IdentityKey as I, type KeyPair as K, PublicEncryptionKey as P, type SignedEncryptedMessage as S, type EncryptedPayload as a, type SignedSymmetricMessage as b, SecretEncryptionKey as c, PrivateEncryptionKey as d, generateEncryptionKeyPair as e, signWithHex as f, generateSigningKeyPair as g, encrypt as h, decrypt as i, decryptWithHex as j, createAuthenticatedMessage as k, createAuthenticatedMessageWithHex as l, mod as m, deriveKeyFromSeed as n, generateNonce as o, pemToCryptoKey as p, generateRandomData as q, exportPrivateKeyPem as r, sign as s, signPayload as t, verifyPayload as u, verify as v, createSignedEncryptedMessage as w, verifyAndDecryptMessage as x, encryptSymmetric as y, decryptSymmetric as z };

package/dist/src/mod.web.d.ts

@@ -1,7 +1,7 @@
-export { C as ClientError, D as DeleteResult, H as HealthStatus, a as HttpClientConfig, L as ListItem, b as ListOptions, c as ListResult, d as LocalStorageClientConfig, N as NodeProtocolInterface, P as PersistenceRecord, R as ReadResult, S as Schema, V as ValidationFn, W as WebSocketClientConfig, e as WebSocketRequest, f as WebSocketResponse, g as WriteResult } from '../types-Bw0Boe0n.js';
+export { C as ClientError, D as DeleteResult, H as HealthStatus, a as HttpClientConfig, L as ListItem, b as ListOptions, c as ListResult, d as LocalStorageClientConfig, N as NodeProtocolInterface, P as PersistenceRecord, R as ReadResult, S as Schema, V as ValidationFn, W as WebSocketClientConfig, e as WebSocketRequest, f as WebSocketResponse, g as WriteResult } from '../types-oQCx3U-_.js';
 export { HttpClient } from '../clients/http/mod.js';
 export { WebSocketClient } from '../clients/websocket/mod.js';
 export { LocalStorageClient } from '../clients/local-storage/mod.js';
 export { WalletClient } from '../wallet/mod.js';
 export { AppsClient } from '../apps/mod.js';
-export { m as encrypt } from '../mod-DHjjiF1o.js';
+export { m as encrypt } from '../mod-D02790g_.js';

package/dist/src/mod.web.js

@@ -1,21 +1,21 @@
 import {
   AppsClient
-} from "../chunk-QHDBFVLU.js";
+} from "../chunk-VAZUCGED.js";
 import {
   mod_exports
-} from "../chunk-G6JDROB4.js";
+} from "../chunk-K3ZSSVHR.js";
 import {
   WalletClient
-} from "../chunk-2D2RT2DW.js";
+} from "../chunk-2VOR4VLG.js";
 import {
   HttpClient
-} from "../chunk-PMBS2GFA.js";
+} from "../chunk-LFUC4ETD.js";
 import {
   LocalStorageClient
-} from "../chunk-XH4OLKBV.js";
+} from "../chunk-7U5JDFQW.js";
 import {
   WebSocketClient
-} from "../chunk-C2ZIFM22.js";
+} from "../chunk-T43IWAQK.js";
 import "../chunk-MLKGABMK.js";
 export {
   AppsClient,

package/dist/{types-Bw0Boe0n.d.ts → types-oQCx3U-_.d.ts}

@@ -198,8 +198,8 @@ interface LocalStorageClientConfig {
  */
 declare class ClientError extends Error {
     readonly code: string;
-    readonly details?: unknown;
-    constructor(message: string, code: string, details?: unknown);
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
 }
 /**
  * WebSocket protocol types for request/response communication