@beep-it/sdk-core 0.1.1 → 0.1.2-beta.2

package/dist/index.d.ts

@@ -5,6 +5,7 @@
 import { InvoicesModule } from './modules/invoices';
 import { PaymentsModule } from './modules/payments';
 import { ProductsModule } from './modules/products';
+import { WidgetModule } from './modules/widget';
 /**
  * Configuration options for initializing the BeepClient
  */
@@ -18,14 +19,24 @@ export interface BeepClientOptions {
     serverUrl?: string;
 }
 /**
- * The main BEEP SDK client for interacting with the BEEP API
+ * 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.
  *
  * @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_api_key_here'
+ *   apiKey: 'your_secret_api_key_here' // Keep this secure!
  * });
  *
  * // Create a payment request
@@ -34,15 +45,27 @@ 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 */
+    /** Access to product management functionality (server-side only) */
     readonly products: ProductsModule;
-    /** Access to invoice management functionality */
+    /** Access to invoice management functionality (server-side only) */
     readonly invoices: InvoicesModule;
-    /** Access to payment processing functionality */
+    /**
+     * 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.
+     */
     readonly payments: PaymentsModule;
     /**
      * Creates a new BEEP client instance
@@ -51,6 +74,23 @@ 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
      *
@@ -70,4 +110,70 @@ export type { CreateCustomInvoicePayload, CreateInvoiceFromProductPayload, Creat
 export type { CreateProductPayload, Product, UpdateProductPayload } from './types/product';
 export { SupportedToken, TokenUtils } from './types/token';
 export type { BeepResponse } from './types';
+export interface BeepPublicClientOptions {
+    /** Publishable key for browser access; safe to embed in clients */
+    publishableKey: string;
+    /** 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.
+     */
+    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';
 //# sourceMappingURL=index.d.ts.map

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;AAEpD;;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"}
+{"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"}

package/dist/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   BeepClient: () => BeepClient,
+  BeepPublicClient: () => BeepPublicClient,
   SupportedToken: () => SupportedToken,
   TokenUtils: () => TokenUtils
 });
@@ -236,22 +237,116 @@ var PaymentsModule = class {
     this.client = client;
   }
   /**
-   * Creates a payment request for purchasing assets
+   * 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.
    *
    * @param input - Parameters for the asset purchase request
-   * @returns Promise that resolves to payment request data, or null if validation fails
+   * @returns Payment request data or null when the input is invalid
    *
    * @example
-   * ```typescript
-   * const payment = await beep.payments.requestAndPurchaseAsset({
-   *   paymentReference: 'premium_subscription_123',
-   *   assetIds: ['asset_1', 'asset_2']
+   * // Phase 1: request
+   * const req = await beep.payments.requestAndPurchaseAsset({
+   *   assets: [{ assetId: 'uuid', quantity: 1 }],
+   *   generateQrCode: true,
+   *   paymentLabel: 'My Store'
    * });
+   * // Show req.paymentUrl/req.qrCode to user; req.referenceKey identifies this payment.
    *
-   * if (payment) {
-   *   console.log('Payment URL:', payment.paymentUrl);
-   * }
-   * ```
+   * // 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
    */
   async requestAndPurchaseAsset(input) {
     if (!input.paymentReference && !input.assets?.length) {
@@ -317,6 +412,143 @@ 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
@@ -454,6 +686,72 @@ var ProductsModule = class {
   }
 };
 
+// src/modules/widget.ts
+var WidgetModule = class {
+  constructor(client, publishableKey) {
+    this.client = client;
+    this.publishableKey = publishableKey;
+  }
+  /**
+   * Creates a payment session (public, CORS-open) for Checkout Widget
+   */
+  async createPaymentSession(input) {
+    const body = {
+      publishableKey: this.publishableKey,
+      assets: input.assets,
+      paymentLabel: input.paymentLabel,
+      generateQrCode: input.generateQrCode ?? true
+    };
+    const res = await this.client.post(
+      "/v1/widget/payment-session",
+      body
+    );
+    return res.data;
+  }
+  /**
+   * Retrieves payment status for a reference key
+   */
+  async getPaymentStatus(referenceKey) {
+    const res = await this.client.get(
+      `/v1/widget/payment-status/${encodeURIComponent(referenceKey)}`
+    );
+    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
 var BeepClient = class {
   /**
@@ -478,6 +776,24 @@ 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
    *
@@ -502,9 +818,31 @@ 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");
+    }
+    this.client = import_axios.default.create({
+      baseURL: options.serverUrl || "https://api.justbeep.it",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Beep-Client": "beep-sdk"
+      }
+    });
+    this.widget = new WidgetModule(this.client, options.publishableKey);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BeepClient,
+  BeepPublicClient,
   SupportedToken,
   TokenUtils
 });