@beep-it/sdk-core 0.1.2-beta.3 → 0.1.2

package/dist/index.d.ts

@@ -19,24 +19,14 @@ export interface BeepClientOptions {
     serverUrl?: string;
 }
 /**
- * The main BEEP SDK client for server-side applications using secret API keys
- *
- * **Use this client for:**
- * - Server-side applications (Node.js, Express, Next.js API routes)
- * - Backend services that can safely store secret API keys
- * - Full payment processing capabilities including streaming payments
- * - Administrative operations like product and invoice management
- *
- * **Security Note:** Never use BeepClient in client-side code (browsers) as it
- * requires secret API keys that should not be exposed publicly.
+ * The main BEEP SDK client for interacting with the BEEP API
  *
  * @example
  * ```typescript
  * import { BeepClient, SupportedToken } from '@beep-it/sdk-core';
  *
- * // Only use this server-side with secret API keys
  * const beep = new BeepClient({
- *   apiKey: 'your_secret_api_key_here' // Keep this secure!
+ *   apiKey: 'your_api_key_here'
  * });
  *
  * // Create a payment request
@@ -45,27 +35,15 @@ export interface BeepClientOptions {
  *   token: SupportedToken.USDT,
  *   description: 'Premium subscription'
  * });
- *
- * // Issue streaming payments (BeepClient only)
- * const streamingSession = await beep.payments.issuePayment({
- *   apiKey: 'your_secret_api_key',
- *   assetChunks: [{ assetId: 'video-content', quantity: 1 }],
- *   payingMerchantId: 'merchant_id'
- * });
  * ```
  */
 export declare class BeepClient {
     private client;
-    /** Access to product management functionality (server-side only) */
+    /** Access to product management functionality */
     readonly products: ProductsModule;
-    /** Access to invoice management functionality (server-side only) */
+    /** Access to invoice management functionality */
     readonly invoices: InvoicesModule;
-    /**
-     * Access to payment processing functionality including streaming payments
-     *
-     * **Note:** Streaming payment methods (issuePayment, startStreaming, pauseStreaming,
-     * stopStreaming) are only available with BeepClient and secret API keys.
-     */
+    /** Access to payment processing functionality */
     readonly payments: PaymentsModule;
     /**
      * Creates a new BEEP client instance
@@ -74,23 +52,6 @@ export declare class BeepClient {
      * @throws {Error} When API key is missing or invalid
      */
     constructor(options: BeepClientOptions);
-    /**
-     * Initiate a payout from your treasury wallet to an external address.
-     * Requires a secret API key (server-side only).
-     *
-     * Notes:
-     * - Do not pass walletId. The server derives the wallet based on your API key's merchant and requested chain.
-     * - amount must be in smallest units for the token (e.g., 6‑decimals USDC amount as an integer string).
-     * - This endpoint responds immediately with acceptance/rejection. Actual transfer executes asynchronously after funds are reserved.
-     *
-     * Example:
-     * const res = await beep.payments.createPayout({
-     *   amount: '1000000', // 1.0 USDC with 6 decimals
-     *   destinationWalletAddress: 'DEST_ADDRESS',
-     *   chain: 'SOLANA',
-     *   token: 'USDC',
-     * });
-     */
     /**
      * Checks the health status of the BEEP API server
      *
@@ -116,63 +77,10 @@ export interface BeepPublicClientOptions {
     /** Optional server URL override */
     serverUrl?: string;
 }
-/**
- * Browser-safe BEEP client for frontend applications using publishable keys
- *
- * **Use this client for:**
- * - Frontend applications (React, Vue, vanilla JavaScript)
- * - Browser-based code where secret keys cannot be safely stored
- * - Widget-based payment sessions with ephemeral items
- * - Client-side payment status polling
- *
- * **Limitations compared to BeepClient:**
- * - Cannot access streaming payment methods (issuePayment, startStreaming, etc.)
- * - Cannot manage products or invoices directly
- * - Limited to public widget endpoints only
- * - No access to administrative functions
- *
- * **Security:** Uses publishable keys which are safe to expose in client-side code.
- *
- * @example
- * ```typescript
- * import { BeepPublicClient } from '@beep-it/sdk-core';
- *
- * // Safe to use in browsers with publishable keys
- * const publicBeep = new BeepPublicClient({
- *   publishableKey: 'beep_pk_your_publishable_key_here' // Safe to expose
- * });
- *
- * // Create payment sessions with mixed assets
- * const session = await publicBeep.widget.createPaymentSession({
- *   assets: [
- *     { assetId: 'existing-product-uuid', quantity: 1 },
- *     { name: 'Custom Item', price: '12.50', quantity: 1 }
- *   ],
- *   paymentLabel: 'My Store'
- * });
- *
- * // Poll for payment completion
- * const { paid } = await publicBeep.widget.waitForPaid({
- *   referenceKey: session.referenceKey
- * });
- * ```
- */
 export declare class BeepPublicClient {
     private client;
-    /**
-     * Access to public widget endpoints for payment sessions
-     *
-     * **Note:** This is the only module available in BeepPublicClient.
-     * Streaming payments, product management, and administrative functions
-     * are only available in BeepClient with secret API keys.
-     */
+    /** Access to public widget endpoints */
     readonly widget: WidgetModule;
-    /**
-     * Creates a new BEEP public client instance for browser use
-     *
-     * @param options - Configuration options including publishable key
-     * @throws {Error} When publishable key is missing or invalid
-     */
     constructor(options: BeepPublicClientOptions);
 }
 export type { PublicPaymentSessionRequest, PublicPaymentSessionResponse, PublicPaymentStatusResponse, EphemeralItem, } from './types/public';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAgB;IAE9B,oEAAoE;IACpE,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC,oEAAoE;IACpE,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC;;;;;OAKG;IACH,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC;;;;;OAKG;gBACS,OAAO,EAAE,iBAAiB;IAmBtC;;;;;;;;;;;;;;;;OAgBG;IAGH;;;;;;;;;;;OAWG;IACU,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;CAW5C;AAOD,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAGpG,YAAY,EACV,0BAA0B,EAC1B,+BAA+B,EAC/B,oBAAoB,EACpB,OAAO,EACP,aAAa,EACb,SAAS,GACV,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG3F,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3D,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAM5C,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,cAAc,EAAE,MAAM,CAAC;IACvB,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAgB;IAE9B;;;;;;OAMG;IACH,SAAgB,MAAM,EAAE,YAAY,CAAC;IAErC;;;;;OAKG;gBACS,OAAO,EAAE,uBAAuB;CAe7C;AAED,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,aAAa,GACd,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAgB;IAE9B,iDAAiD;IACjD,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC,iDAAiD;IACjD,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC,iDAAiD;IACjD,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC;;;;;OAKG;gBACS,OAAO,EAAE,iBAAiB;IAmBtC;;;;;;;;;;;OAWG;IACU,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;CAW5C;AAOD,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAGpG,YAAY,EACV,0BAA0B,EAC1B,+BAA+B,EAC/B,oBAAoB,EACpB,OAAO,EACP,aAAa,EACb,SAAS,GACV,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG3F,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3D,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAM5C,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,cAAc,EAAE,MAAM,CAAC;IACvB,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAgB;IAC9B,wCAAwC;IACxC,SAAgB,MAAM,EAAE,YAAY,CAAC;gBAEzB,OAAO,EAAE,uBAAuB;CAe7C;AAED,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,aAAa,GACd,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -237,116 +237,22 @@ var PaymentsModule = class {
     this.client = client;
   }
   /**
-   * Initiate a payout from your treasury wallet to an external address.
-   * Requires a secret API key (server-side only).
-   *
-   * Notes:
-   * - Do not pass walletId. The server derives the wallet based on your API key's merchant and requested chain.
-   * - amount must be in smallest units for the token (e.g., 6‑decimals USDC amount as an integer string).
-   * - This endpoint responds immediately with acceptance/rejection. Actual transfer executes asynchronously after funds are reserved.
-   *
-   * Example:
-   * const res = await beep.payments.createPayout({
-   *   amount: '1000000', // 1.0 USDC with 6 decimals
-   *   destinationWalletAddress: 'DEST_ADDRESS',
-   *   chain: 'SOLANA',
-   *   token: 'USDC',
-   * });
-   */
-  async createPayout(params) {
-    const { data } = await this.client.post("/v1/payouts", params);
-    return data;
-  }
-  /**
-   * Waits for a payment to complete by polling the 402 endpoint using a reference key.
-   * The request is considered complete when the response no longer includes `referenceKey`.
-   */
-  async waitForPaymentCompletion(options) {
-    const baseIntervalMs = options.intervalMs ?? 15e3;
-    let currentIntervalMs = baseIntervalMs;
-    const timeoutMs = options.timeoutMs ?? 5 * 6e4;
-    const deadline = Date.now() + timeoutMs;
-    let last = null;
-    while (true) {
-      if (options.signal?.aborted) {
-        return { paid: false, last };
-      }
-      try {
-        try {
-          const resp = await this.client.post(
-            `/v1/payment/request-payment`,
-            {
-              assets: options.assets,
-              paymentReference: options.paymentReference,
-              paymentLabel: options.paymentLabel,
-              generateQrCode: false
-            }
-          );
-          last = resp.data.data;
-        } catch (err) {
-          const ax = err;
-          const status = ax.response?.status;
-          if (status === 402) {
-            last = ax.response?.data?.data ?? null;
-          } else {
-            if (status && [400, 401, 403, 404, 422].includes(status)) {
-              options.onError?.(err);
-              return { paid: false, last };
-            }
-            options.onError?.(err);
-            currentIntervalMs = Math.min(Math.ceil(currentIntervalMs * 1.5), 6e4);
-            last = last ?? null;
-          }
-        }
-        options.onUpdate?.(last);
-        if (last?.status === "expired" /* EXPIRED */ || last?.status === "failed" /* FAILED */) {
-          return { paid: false, last };
-        }
-        const paid = !last?.referenceKey;
-        if (paid) return { paid: true, last };
-        currentIntervalMs = baseIntervalMs;
-      } catch (e) {
-        options.onError?.(e);
-        currentIntervalMs = Math.min(Math.ceil(currentIntervalMs * 1.5), 6e4);
-      }
-      if (Date.now() >= deadline) return { paid: false, last };
-      await new Promise((r) => setTimeout(r, currentIntervalMs));
-    }
-  }
-  /**
-   * Creates a payment request for purchasing assets using a two‑phase 402 flow.
-   *
-   * Phase 1 – Request payment (no paymentReference):
-   * - Server responds with HTTP 402 Payment Required and a payload containing:
-   *   referenceKey, paymentUrl (Solana Pay), optional qrCode, amount, expiresAt, status.
-   * - The SDK normalizes this by returning the payload (even when status code is 402).
-   * - The caller must instruct the user to pay via their wallet using paymentUrl/qrCode.
-   *
-   * Phase 2 – Check/complete payment (with paymentReference):
-   * - Call again with the same assets and paymentReference returned in Phase 1.
-   * - If payment is still pending, server may again provide the referenceKey (or return 402).
-   * - When payment is complete, server will return success (no referenceKey required). In this SDK
-   *   we consider the payment complete when the response does NOT include referenceKey.
+   * Creates a payment request for purchasing assets
    *
    * @param input - Parameters for the asset purchase request
-   * @returns Payment request data or null when the input is invalid
+   * @returns Promise that resolves to payment request data, or null if validation fails
    *
    * @example
-   * // Phase 1: request
-   * const req = await beep.payments.requestAndPurchaseAsset({
-   *   assets: [{ assetId: 'uuid', quantity: 1 }],
-   *   generateQrCode: true,
-   *   paymentLabel: 'My Store'
+   * ```typescript
+   * const payment = await beep.payments.requestAndPurchaseAsset({
+   *   paymentReference: 'premium_subscription_123',
+   *   assetIds: ['asset_1', 'asset_2']
    * });
-   * // Show req.paymentUrl/req.qrCode to user; req.referenceKey identifies this payment.
    *
-   * // Phase 2: poll status using the same API with the referenceKey
-   * const check = await beep.payments.requestAndPurchaseAsset({
-   *   assets: [{ assetId: 'uuid', quantity: 1 }],
-   *   paymentReference: req?.referenceKey,
-   *   generateQrCode: false
-   * });
-   * const isPaid = !check?.referenceKey; // When no referenceKey is returned, payment is complete
+   * if (payment) {
+   *   console.log('Payment URL:', payment.paymentUrl);
+   * }
+   * ```
    */
   async requestAndPurchaseAsset(input) {
     if (!input.paymentReference && !input.assets?.length) {
@@ -412,143 +318,6 @@ var PaymentsModule = class {
       throw new Error(`Failed to sign solana transaction: ${errorMessage}`);
     }
   }
-  // --- Streaming Payment Methods ---
-  // Note: These methods are ONLY available with BeepClient (secret API keys)
-  // They do NOT work with BeepPublicClient (publishable keys)
-  /**
-   * Issues a payment request for streaming charges with specified asset chunks
-   *
-   * Creates a new streaming payment session that can be started, paused, and stopped.
-   * This is the first step in setting up automatic billing for ongoing services or
-   * consumption-based pricing.
-   *
-   * **Important Security Note**: This method requires a secret API key and is only
-   * available when using `BeepClient`. It will NOT work with `BeepPublicClient` or
-   * publishable keys for security reasons.
-   *
-   * @param payload - Payment request details including assets and merchant information
-   * @returns Promise resolving to payment session identifiers
-   * @throws {Error} When the request fails or authentication is invalid
-   *
-   * @example
-   * ```typescript
-   * // Only works with BeepClient (server-side)
-   * const beep = new BeepClient({ apiKey: 'your_secret_api_key' });
-   *
-   * const paymentSession = await beep.payments.issuePayment({
-   *   apiKey: 'your_secret_api_key',
-   *   assetChunks: [
-   *     { assetId: 'video-streaming-uuid', quantity: 1 },
-   *     { assetId: 'api-calls-uuid', quantity: 100 }
-   *   ],
-   *   payingMerchantId: 'merchant_who_will_be_charged',
-   *   invoiceId: 'optional_existing_invoice_uuid'
-   * });
-   *
-   * console.log('Payment session created:', paymentSession.referenceKey);
-   * console.log('Invoice ID for management:', paymentSession.invoiceId);
-   * ```
-   */
-  async issuePayment(payload) {
-    const response = await this.client.post(
-      "/v1/invoices/issue-payment",
-      payload
-    );
-    return response.data;
-  }
-  /**
-   * Starts an active streaming session and begins charging for asset usage
-   *
-   * Activates a previously issued payment request and begins billing the specified
-   * merchant according to the streaming payment configuration. Once started, charges
-   * will accumulate based on actual usage.
-   *
-   * **Important Security Note**: This method requires a secret API key and is only
-   * available when using `BeepClient`. It will NOT work with `BeepPublicClient`.
-   *
-   * @param payload - Streaming session start details
-   * @returns Promise resolving to confirmation of the started session
-   * @throws {Error} When the invoice is invalid or already active
-   *
-   * @example
-   * ```typescript
-   * // Start billing for the streaming session
-   * const result = await beep.payments.startStreaming({
-   *   apiKey: 'your_secret_api_key',
-   *   invoiceId: 'invoice_uuid_from_issuePayment'
-   * });
-   *
-   * console.log('Streaming started for invoice:', result.invoiceId);
-   * // Charges will now accumulate based on usage
-   * ```
-   */
-  async startStreaming(payload) {
-    const response = await this.client.post("/v1/invoices/start", payload);
-    return response.data;
-  }
-  /**
-   * Temporarily pauses an active streaming session without terminating it
-   *
-   * Halts billing for a streaming session while keeping the session alive for later resumption.
-   * This is useful for temporary service interruptions or when you want to control billing
-   * periods precisely.
-   *
-   * **Important Security Note**: This method requires a secret API key and is only
-   * available when using `BeepClient`. It will NOT work with `BeepPublicClient`.
-   *
-   * @param payload - Streaming session pause details
-   * @returns Promise resolving to pause operation result
-   * @throws {Error} When the invoice is not in a valid state for pausing
-   *
-   * @example
-   * ```typescript
-   * // Temporarily pause billing (can be resumed later)
-   * const result = await beep.payments.pauseStreaming({
-   *   apiKey: 'your_secret_api_key',
-   *   invoiceId: 'active_streaming_invoice_uuid'
-   * });
-   *
-   * if (result.success) {
-   *   console.log('Streaming paused - no new charges will accumulate');
-   *   // Use startStreaming() again to resume
-   * }
-   * ```
-   */
-  async pauseStreaming(payload) {
-    const response = await this.client.post("/v1/invoices/pause", payload);
-    return response.data;
-  }
-  /**
-   * Permanently stops a streaming session and finalizes all charges
-   *
-   * Terminates a streaming session completely, finalizing all accumulated charges.
-   * This action cannot be undone - the session cannot be restarted after stopping.
-   * Use this when you're completely finished with a service or want to close out billing.
-   *
-   * **Important Security Note**: This method requires a secret API key and is only
-   * available when using `BeepClient`. It will NOT work with `BeepPublicClient`.
-   *
-   * @param payload - Streaming session stop details
-   * @returns Promise resolving to final session details and reference keys
-   * @throws {Error} When the invoice cannot be stopped or doesn't exist
-   *
-   * @example
-   * ```typescript
-   * // Permanently stop and finalize the streaming session
-   * const result = await beep.payments.stopStreaming({
-   *   apiKey: 'your_secret_api_key',
-   *   invoiceId: 'active_streaming_invoice_uuid'
-   * });
-   *
-   * console.log('Session permanently stopped:', result.invoiceId);
-   * console.log('All reference keys for records:', result.referenceKeys);
-   * // Session cannot be restarted after this point
-   * ```
-   */
-  async stopStreaming(payload) {
-    const response = await this.client.post("/v1/invoices/stop", payload);
-    return response.data;
-  }
 };
 
 // src/modules/products.ts
@@ -717,39 +486,6 @@ var WidgetModule = class {
     );
     return res.data;
   }
-  /**
-   * Waits for payment completion by polling the public status endpoint until paid or timeout.
-   * Designed for browser/public usage (no secret keys).
-   */
-  async waitForPaid(options) {
-    const baseIntervalMs = options.intervalMs ?? 15e3;
-    let currentIntervalMs = baseIntervalMs;
-    const timeoutMs = options.timeoutMs ?? 5 * 6e4;
-    const deadline = Date.now() + timeoutMs;
-    let last;
-    while (true) {
-      if (options.signal?.aborted) return { paid: false, last };
-      try {
-        const res = await this.client.get(
-          `/v1/widget/payment-status/${encodeURIComponent(options.referenceKey)}`
-        );
-        last = res.data;
-        options.onUpdate?.(last);
-        if (last?.paid) return { paid: true, last };
-        currentIntervalMs = baseIntervalMs;
-      } catch (err) {
-        options.onError?.(err);
-        const ax = err;
-        const status = ax.response?.status;
-        if (status && [400, 401, 403, 404, 422].includes(status)) {
-          return { paid: false, last };
-        }
-        currentIntervalMs = Math.min(Math.ceil(currentIntervalMs * 1.5), 6e4);
-      }
-      if (Date.now() >= deadline) return { paid: false, last };
-      await new Promise((r) => setTimeout(r, currentIntervalMs));
-    }
-  }
 };
 
 // src/index.ts
@@ -776,24 +512,6 @@ var BeepClient = class {
     this.invoices = new InvoicesModule(this.client);
     this.payments = new PaymentsModule(this.client);
   }
-  /**
-   * Initiate a payout from your treasury wallet to an external address.
-   * Requires a secret API key (server-side only).
-   *
-   * Notes:
-   * - Do not pass walletId. The server derives the wallet based on your API key's merchant and requested chain.
-   * - amount must be in smallest units for the token (e.g., 6‑decimals USDC amount as an integer string).
-   * - This endpoint responds immediately with acceptance/rejection. Actual transfer executes asynchronously after funds are reserved.
-   *
-   * Example:
-   * const res = await beep.payments.createPayout({
-   *   amount: '1000000', // 1.0 USDC with 6 decimals
-   *   destinationWalletAddress: 'DEST_ADDRESS',
-   *   chain: 'SOLANA',
-   *   token: 'USDC',
-   * });
-   */
-  // Deprecated: use beep.payments.createPayout()
   /**
    * Checks the health status of the BEEP API server
    *
@@ -819,12 +537,6 @@ var BeepClient = class {
   }
 };
 var BeepPublicClient = class {
-  /**
-   * Creates a new BEEP public client instance for browser use
-   *
-   * @param options - Configuration options including publishable key
-   * @throws {Error} When publishable key is missing or invalid
-   */
   constructor(options) {
     if (!options.publishableKey) {
       throw new Error("publishableKey is required to initialize BeepPublicClient");