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

package/dist/index.mjs

@@ -200,116 +200,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) {
@@ -375,143 +281,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
@@ -680,39 +449,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
@@ -739,24 +475,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
    *
@@ -782,12 +500,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");

package/dist/modules/payments.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { BeepPurchaseAsset, IssuePaymentPayload, IssuePaymentResponse, PauseStreamingPayload, PauseStreamingResponse, PaymentRequestData, RequestAndPurchaseAssetRequestParams, SignSolanaTransactionData, SignSolanaTransactionParams, StartStreamingPayload, StartStreamingResponse, StopStreamingPayload, StopStreamingResponse } from '../types';
+import { PaymentRequestData, RequestAndPurchaseAssetRequestParams, SignSolanaTransactionData, SignSolanaTransactionParams } from '../types/payment';
 /**
  * Module for handling payment operations including asset purchases and Solana transactions
  * Provides methods for creating payment requests and signing blockchain transactions
@@ -8,88 +8,22 @@ export declare class PaymentsModule {
     private client;
     constructor(client: AxiosInstance);
     /**
-     * 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',
-     * });
-     */
-    createPayout(params: {
-        amount: string;
-        destinationWalletAddress: string;
-        chain: string;
-        token: string;
-    }): Promise<{
-        payoutId: string;
-        status: 'accepted' | 'rejected';
-        message: string;
-        withdrawRequestId?: number;
-        requestedAmount?: string;
-        reservedAmount?: string;
-        createdAt: string;
-        error?: string;
-    }>;
-    /**
-     * 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`.
-     */
-    waitForPaymentCompletion(options: {
-        assets: BeepPurchaseAsset[];
-        paymentReference: string;
-        paymentLabel?: string;
-        intervalMs?: number;
-        timeoutMs?: number;
-        signal?: AbortSignal;
-        onUpdate?: (response: PaymentRequestData | null) => void;
-        onError?: (error: unknown) => void;
-    }): Promise<{
-        paid: boolean;
-        last?: PaymentRequestData | null;
-    }>;
-    /**
-     * 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);
+     * }
+     * ```
      */
     requestAndPurchaseAsset(input: RequestAndPurchaseAssetRequestParams): Promise<PaymentRequestData | null>;
     /**
@@ -119,124 +53,5 @@ export declare class PaymentsModule {
      * ```
      */
     signSolanaTransaction(input: SignSolanaTransactionParams): Promise<SignSolanaTransactionData | null>;
-    /**
-     * 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);
-     * ```
-     */
-    issuePayment(payload: IssuePaymentPayload): Promise<IssuePaymentResponse>;
-    /**
-     * 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
-     * ```
-     */
-    startStreaming(payload: StartStreamingPayload): Promise<StartStreamingResponse>;
-    /**
-     * 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
-     * }
-     * ```
-     */
-    pauseStreaming(payload: PauseStreamingPayload): Promise<PauseStreamingResponse>;
-    /**
-     * 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
-     * ```
-     */
-    stopStreaming(payload: StopStreamingPayload): Promise<StopStreamingResponse>;
 }
 //# sourceMappingURL=payments.d.ts.map

package/dist/modules/payments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payments.d.ts","sourceRoot":"","sources":["../../src/modules/payments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,aAAa,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,oCAAoC,EAEpC,yBAAyB,EACzB,2BAA2B,EAE3B,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,UAAU,CAAC;AAGlB;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,aAAa;IAIjC;;;;;;;;;;;;;;;;OAgBG;IACU,YAAY,CAAC,MAAM,EAAE;QAChC,MAAM,EAAE,MAAM,CAAC;QACf,wBAAwB,EAAE,MAAM,CAAC;QACjC,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,GAAG,OAAO,CAAC;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;QAChC,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAKF;;;OAGG;IACU,wBAAwB,CAAC,OAAO,EAAE;QAC7C,MAAM,EAAE,iBAAiB,EAAE,CAAC;QAC5B,gBAAgB,EAAE,MAAM,CAAC;QACzB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,KAAK,IAAI,CAAC;QACzD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;KACpC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAA;KAAE,CAAC;IA+DhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACG,uBAAuB,CAC3B,KAAK,EAAE,oCAAoC,GAC1C,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAuBrC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,qBAAqB,CAChC,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAgC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAQ/E;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAKrF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAKrF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAInF"}
+{"version":3,"file":"payments.d.ts","sourceRoot":"","sources":["../../src/modules/payments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EACL,kBAAkB,EAClB,oCAAoC,EACpC,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAE1B;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,aAAa;IAIjC;;;;;;;;;;;;;;;;;OAiBG;IACG,uBAAuB,CAC3B,KAAK,EAAE,oCAAoC,GAC1C,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAqBrC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,qBAAqB,CAChC,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;CA2B7C"}

package/dist/modules/widget.d.ts

@@ -12,20 +12,5 @@ export declare class WidgetModule {
      * Retrieves payment status for a reference key
      */
     getPaymentStatus(referenceKey: string): Promise<PublicPaymentStatusResponse>;
-    /**
-     * Waits for payment completion by polling the public status endpoint until paid or timeout.
-     * Designed for browser/public usage (no secret keys).
-     */
-    waitForPaid(options: {
-        referenceKey: string;
-        intervalMs?: number;
-        timeoutMs?: number;
-        signal?: AbortSignal;
-        onUpdate?: (status: PublicPaymentStatusResponse) => void;
-        onError?: (error: unknown) => void;
-    }): Promise<{
-        paid: boolean;
-        last?: PublicPaymentStatusResponse;
-    }>;
 }
 //# sourceMappingURL=widget.d.ts.map

package/dist/modules/widget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"widget.d.ts","sourceRoot":"","sources":["../../src/modules/widget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,aAAa,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,iBAAiB,CAAC;AAEzB,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,cAAc,CAAS;gBAEnB,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM;IAKzD;;OAEG;IACG,oBAAoB,CACxB,KAAK,EAAE,IAAI,CAAC,2BAA2B,EAAE,gBAAgB,CAAC,GACzD,OAAO,CAAC,4BAA4B,CAAC;IAcxC;;OAEG;IACG,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAOlF;;;OAGG;IACG,WAAW,CAAC,OAAO,EAAE;QACzB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,2BAA2B,KAAK,IAAI,CAAC;QACzD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;KACpC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,2BAA2B,CAAA;KAAE,CAAC;CAkCnE"}
+{"version":3,"file":"widget.d.ts","sourceRoot":"","sources":["../../src/modules/widget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,iBAAiB,CAAC;AAEzB,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,cAAc,CAAS;gBAEnB,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM;IAKzD;;OAEG;IACG,oBAAoB,CACxB,KAAK,EAAE,IAAI,CAAC,2BAA2B,EAAE,gBAAgB,CAAC,GACzD,OAAO,CAAC,4BAA4B,CAAC;IAcxC;;OAEG;IACG,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,2BAA2B,CAAC;CAMnF"}

package/dist/types/index.d.ts

@@ -1,8 +1,7 @@
 export * from './invoice';
-export * from './payment';
 export * from './product';
 export * from './token';
-import { PaymentRequestData, SignSolanaTransactionData } from './payment';
+export * from './payment';
 /**
  * Standard response wrapper for BEEP API endpoints
  * All API responses follow this structure
@@ -29,4 +28,5 @@ export interface SignSolanaTransactionResponse extends BeepResponse {
     /** Signed transaction data and associated invoice information */
     data: SignSolanaTransactionData;
 }
+import { PaymentRequestData, SignSolanaTransactionData } from './payment';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAC1E;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,4BAA4B;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,+BAAgC,SAAQ,YAAY;IACnE,uEAAuE;IACvE,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,6BAA8B,SAAQ,YAAY;IACjE,iEAAiE;IACjE,IAAI,EAAE,yBAAyB,CAAC;CACjC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAE1B;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,4BAA4B;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,+BAAgC,SAAQ,YAAY;IACnE,uEAAuE;IACvE,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,6BAA8B,SAAQ,YAAY;IACjE,iEAAiE;IACjE,IAAI,EAAE,yBAAyB,CAAC;CACjC;AAGD,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC"}