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

package/dist/index.mjs

@@ -200,22 +200,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) {
@@ -281,6 +375,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
@@ -418,6 +649,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 {
   /**
@@ -442,6 +739,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
    *
@@ -466,8 +781,30 @@ 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 = axios.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);
+  }
+};
 export {
   BeepClient,
+  BeepPublicClient,
   SupportedToken,
   TokenUtils
 };

package/dist/modules/payments.d.ts

@@ -1,5 +1,6 @@
 import { AxiosInstance } from 'axios';
-import { PaymentRequestData, RequestAndPurchaseAssetRequestParams, SignSolanaTransactionData, SignSolanaTransactionParams } from '../types/payment';
+import { IssuePaymentPayload, IssuePaymentResponse, PauseStreamingPayload, PauseStreamingResponse, StartStreamingPayload, StartStreamingResponse, StopStreamingPayload, StopStreamingResponse } from '../types';
+import { BeepPurchaseAsset, 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,22 +9,88 @@ export declare class PaymentsModule {
     private client;
     constructor(client: AxiosInstance);
     /**
-     * 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',
+     * });
+     */
+    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.
      *
      * @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
      */
     requestAndPurchaseAsset(input: RequestAndPurchaseAssetRequestParams): Promise<PaymentRequestData | null>;
     /**
@@ -53,5 +120,124 @@ 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,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"}
+{"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,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EAGtB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,iBAAiB,EACjB,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;;;;;;;;;;;;;;;;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"}

package/dist/modules/widget.d.ts

@@ -0,0 +1,31 @@
+import { AxiosInstance } from 'axios';
+import { PublicPaymentSessionRequest, PublicPaymentSessionResponse, PublicPaymentStatusResponse } from '../types/public';
+export declare class WidgetModule {
+    private client;
+    private publishableKey;
+    constructor(client: AxiosInstance, publishableKey: string);
+    /**
+     * Creates a payment session (public, CORS-open) for Checkout Widget
+     */
+    createPaymentSession(input: Omit<PublicPaymentSessionRequest, 'publishableKey'>): Promise<PublicPaymentSessionResponse>;
+    /**
+     * 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

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