@moneymq/sdk 0.9.4 → 0.10.0

package/dist/index.d.mts

@@ -248,7 +248,7 @@ declare class CatalogAPI {
 }
 
 /**
- * MoneyMQ Channel API - Listener, Processor, and Actor patterns
+ * MoneyMQ Channel API - Listener, PaymentStream, and PaymentHook patterns
  *
  * Provides pub/sub event communication over SSE with optional publish capability.
  *
@@ -259,16 +259,16 @@ declare class CatalogAPI {
  * listener.connect();
  * ```
  *
- * @example Processor (backend - transaction spawner)
+ * @example PaymentStream (backend - transaction spawner)
  * ```typescript
- * const processor = moneymq.payment.processor();
- * processor.on('transaction', (tx) => {
- *   const actor = tx.actor();
- *   actor.on('payment:settled', async (event) => {
- *     await actor.send('order:completed', { ... });
+ * const stream = moneymq.payment.paymentStream();
+ * stream.on('transaction', (tx) => {
+ *   const hook = tx.hook();
+ *   hook.on('payment:settled', async (event) => {
+ *     await hook.attach('fulfillment', { orderId: tx.id });
  *   });
  * });
- * processor.connect();
+ * stream.connect();
  * ```
  */
 declare class EventSource {
@@ -389,18 +389,22 @@ interface ReaderOptions {
     maxReconnectAttempts?: number;
 }
 /**
- * Actor options (subscribe + publish)
+ * PaymentHook options (subscribe + publish)
  */
-interface ActorOptions extends ReaderOptions {
+interface PaymentHookOptions extends ReaderOptions {
     /** Secret for authorization (uses client secret if not provided) */
     secret?: string;
+    /** Actor ID for identifying this hook in attachments (required for attach) */
+    actorId?: string;
 }
 /**
- * Receiver options (transaction listener)
+ * PaymentStream options (transaction listener)
  */
-interface ReceiverOptions {
+interface PaymentStreamOptions {
     /** Secret for authorization (uses client secret if not provided) */
     secret?: string;
+    /** Actor ID for identifying this hook in attachments (required for attach) */
+    actorId?: string;
     /** Auto-reconnect on disconnect */
     autoReconnect?: boolean;
     /** Reconnect delay in ms */
@@ -452,15 +456,15 @@ interface ErrorStreamMessage {
     error: ChannelError;
 }
 /**
- * Transaction with actor factory method and convenience methods
+ * Transaction with hook factory method and convenience methods
  */
-interface TransactionWithActor extends Transaction {
-    /** Create an actor scoped to this transaction's channel */
-    actor(options?: Omit<ActorOptions, 'secret'>): EventActor;
+interface TransactionWithHook extends Transaction {
+    /** Create a hook scoped to this transaction's channel */
+    hook(options?: Omit<PaymentHookOptions, 'secret'>): PaymentHook;
     /**
      * Stream events for this transaction
      *
-     * Creates an actor internally and yields events from the transaction's channel.
+     * Creates a hook internally and yields events from the transaction's channel.
      */
     events(options?: {
         signal?: AbortSignal;
@@ -468,18 +472,21 @@ interface TransactionWithActor extends Transaction {
     /**
      * Attach data to this transaction's channel
      *
-     * Creates an actor internally if not already created.
+     * Creates a hook internally if not already created.
      * The server will create a signed receipt JWT and emit a transaction:completed event.
+     *
+     * @param key - Attachment key identifying this fulfillment (e.g., 'fulfillment', 'surfnet')
+     * @param data - Data to attach
      */
-    attach<T = unknown>(data: T): Promise<ChannelEvent<T>>;
+    attach<T = unknown>(key: string, data: T): Promise<ChannelEvent<T>>;
 }
 /**
- * Transaction message (for receivers)
- * Note: The transaction has an actor() method to create a scoped EventActor
+ * Transaction message (for payment streams)
+ * Note: The transaction has a hook() method to create a scoped PaymentHook
  */
 interface TransactionStreamMessage {
     type: 'transaction';
-    transaction: TransactionWithActor;
+    transaction: TransactionWithHook;
 }
 /**
  * Union of all channel stream message types
@@ -624,49 +631,51 @@ declare class EventReader extends BaseChannel {
     protected buildUrl(): string;
 }
 /**
- * Event actor - subscribe + publish channel connection
+ * Payment hook - subscribe + publish channel connection
  *
- * Use for backend applications that need to receive events and publish responses.
+ * Use for backend applications that need to receive events and attach fulfillment data.
  *
  * @example
  * ```typescript
- * const actor = new EventActor('http://localhost:8488', 'order-123', {
+ * const hook = new PaymentHook('http://localhost:8488', 'order-123', {
  *   secret: 'your-secret'
  * });
  *
- * actor.on('payment:settled', async (event) => {
+ * hook.on('payment:settled', async (event) => {
  *   // Process the payment
  *   const order = await processOrder(event.data);
  *
- *   // Publish completion event to all channel subscribers
- *   await actor.send('order:completed', {
+ *   // Attach fulfillment data - server creates signed receipt
+ *   await hook.attach('fulfillment', {
  *     orderId: order.id,
  *     trackingNumber: order.tracking
  *   });
  * });
  *
- * actor.connect();
+ * hook.connect();
  * ```
  */
-declare class EventActor extends BaseChannel {
+declare class PaymentHook extends BaseChannel {
     private secret?;
-    constructor(endpoint: string, channelId: string, options: ActorOptions);
+    private actorId?;
+    constructor(endpoint: string, channelId: string, options: PaymentHookOptions);
     protected buildUrl(): string;
     /**
-     * Publish an event to the channel
+     * Attach data to the channel
      *
-     * All connected readers and actors on this channel will receive the event.
+     * The server will create a signed receipt JWT and emit a transaction:completed event.
+     * Attachments are stored as: attachments[actorId][key] = data
      *
-     * @param type - Event type (e.g., 'order:completed')
-     * @param data - Event payload
+     * @param key - Attachment key identifying this fulfillment (e.g., 'fulfillment', 'surfnet')
+     * @param data - Data to attach
      * @returns The created event
      */
-    send<T = unknown>(type: string, data: T): Promise<ChannelEvent<T>>;
+    attach<T = unknown>(key: string, data: T): Promise<ChannelEvent<T>>;
 }
 /**
- * Transaction wrapper for receiver callbacks
+ * Transaction wrapper for payment stream callbacks
  */
-declare class TransactionContext implements TransactionWithActor {
+declare class TransactionContext implements TransactionWithHook {
     id: string;
     channelId: string;
     basket: BasketItem$1[];
@@ -674,12 +683,13 @@ declare class TransactionContext implements TransactionWithActor {
     metadata?: Record<string, unknown>;
     private endpoint;
     private secret;
-    private _actor;
-    constructor(data: Transaction, endpoint: string, secret: string);
+    private actorId?;
+    private _hook;
+    constructor(data: Transaction, endpoint: string, secret: string, actorId?: string);
     /**
-     * Get or create the internal actor (lazy initialization)
+     * Get or create the internal hook (lazy initialization)
      */
-    private getOrCreateActor;
+    private getOrCreateHook;
     /**
      * Get the payment amount as string (from payment details)
      */
@@ -705,22 +715,22 @@ declare class TransactionContext implements TransactionWithActor {
      */
     get features(): Record<string, ProductFeature> | unknown | undefined;
     /**
-     * Create an actor scoped to this transaction's channel
+     * Create a hook scoped to this transaction's channel
      *
-     * The actor is automatically connected.
-     * Note: If you use events() or send() methods, they share the same internal actor.
+     * The hook is automatically connected.
+     * Note: If you use events() or attach() methods, they share the same internal hook.
      */
-    actor(options?: Omit<ActorOptions, 'secret'>): EventActor;
+    hook(options?: Omit<PaymentHookOptions, 'secret' | 'actorId'>): PaymentHook;
     /**
      * Stream events for this transaction
      *
-     * Creates an actor internally and yields events from the transaction's channel.
+     * Creates a hook internally and yields events from the transaction's channel.
      *
      * @example
      * ```typescript
      * for await (const event of tx.events()) {
      *   if (event.type === 'payment:settled') {
-     *     await tx.send('order:completed', { orderId: tx.id });
+     *     await tx.attach('fulfillment', { orderId: tx.id });
      *     break;
      *   }
      * }
@@ -732,48 +742,53 @@ declare class TransactionContext implements TransactionWithActor {
     /**
      * Attach data to this transaction's channel
      *
-     * Creates an actor internally if not already created.
+     * Creates a hook internally if not already created.
      * The server will create a signed receipt JWT and emit a transaction:completed event.
+     * Attachments are stored as: attachments[actorId][key] = data
+     *
+     * @param key - Attachment key identifying this fulfillment (e.g., 'fulfillment', 'surfnet')
+     * @param data - Data to attach
      *
      * @example
      * ```typescript
-     * await tx.attach({ orderId: tx.id, trackingNumber: '...' });
+     * await tx.attach('fulfillment', { orderId: tx.id, trackingNumber: '...' });
      * ```
      */
-    attach<T = unknown>(data: T): Promise<ChannelEvent<T>>;
+    attach<T = unknown>(key: string, data: T): Promise<ChannelEvent<T>>;
 }
 /**
  * Transaction handler callback
  */
 type TransactionHandler = (tx: TransactionContext) => void | Promise<void>;
 /**
- * Event receiver - listens for new transactions and spawns actors
+ * Payment stream - listens for new transactions and spawns hooks
  *
  * Use for backend applications that need to handle multiple concurrent transactions.
  *
  * @example
  * ```typescript
- * const receiver = new EventReceiver('http://localhost:8488', {
+ * const stream = new PaymentStream('http://localhost:8488', {
  *   secret: 'your-secret'
  * });
  *
- * receiver.on('transaction', (tx) => {
+ * stream.on('transaction', (tx) => {
  *   console.log('New transaction:', tx.id);
  *
- *   const actor = tx.actor();
+ *   const hook = tx.hook();
  *
- *   actor.on('payment:settled', async (event) => {
+ *   hook.on('payment:settled', async (event) => {
  *     await processPayment(event.data);
- *     await actor.send('order:completed', { orderId: tx.id });
+ *     await hook.attach('fulfillment', { orderId: tx.id });
  *   });
  * });
  *
- * receiver.connect();
+ * stream.connect();
  * ```
  */
-declare class EventReceiver {
+declare class PaymentStream {
     private endpoint;
     private secret?;
+    private actorId?;
     private options;
     private eventSource;
     private state;
@@ -782,7 +797,7 @@ declare class EventReceiver {
     private connectionHandlers;
     private disconnectionHandlers;
     private errorHandlers;
-    constructor(endpoint: string, options?: ReceiverOptions);
+    constructor(endpoint: string, options?: PaymentStreamOptions);
     /**
      * Current connection state
      */
@@ -820,14 +835,14 @@ declare class EventReceiver {
      *
      * @example
      * ```typescript
-     * const receiver = moneymq.payment.processor();
+     * const stream = moneymq.payment.paymentStream();
      *
-     * for await (const message of receiver.stream()) {
+     * for await (const message of stream.stream()) {
      *   if (message.type === 'transaction') {
      *     const tx = message.transaction;
      *     console.log('New transaction:', tx.id);
      *
-     *     const actor = tx.actor();
+     *     const hook = tx.hook();
      *     // Handle the transaction...
      *   } else if (message.type === 'state') {
      *     console.log('State:', message.state);
@@ -846,15 +861,15 @@ declare class EventReceiver {
      *
      * @example
      * ```typescript
-     * const processor = moneymq.payment.processor();
+     * const stream = moneymq.payment.paymentStream();
      *
-     * for await (const tx of processor.transactions()) {
+     * for await (const tx of stream.transactions()) {
      *   console.log('New transaction:', tx.id, tx.payment?.amount);
      *
-     *   const actor = tx.actor();
-     *   for await (const event of actor.events()) {
+     *   const hook = tx.hook();
+     *   for await (const event of hook.events()) {
      *     if (event.type === 'payment:settled') {
-     *       await actor.send('order:completed', { orderId: tx.id });
+     *       await hook.attach('fulfillment', { orderId: tx.id });
      *       break;
      *     }
      *   }
@@ -863,7 +878,7 @@ declare class EventReceiver {
      */
     transactions(options?: {
         signal?: AbortSignal;
-    }): AsyncGenerator<TransactionWithActor>;
+    }): AsyncGenerator<TransactionWithHook>;
     private setState;
     private shouldReconnect;
     private scheduleReconnect;
@@ -874,13 +889,13 @@ declare class EventReceiver {
  */
 declare function createEventReader(endpoint: string, channelId: string, options?: ReaderOptions): EventReader;
 /**
- * Create an event actor
+ * Create a payment hook
  */
-declare function createEventActor(endpoint: string, channelId: string, options: ActorOptions): EventActor;
+declare function createPaymentHook(endpoint: string, channelId: string, options: PaymentHookOptions): PaymentHook;
 /**
- * Create an event receiver
+ * Create a payment stream
  */
-declare function createEventReceiver(endpoint: string, options: ReceiverOptions): EventReceiver;
+declare function createPaymentStream(endpoint: string, options: PaymentStreamOptions): PaymentStream;
 
 /** Line item for checkout session creation - references catalog products */
 interface CheckoutLineItem {
@@ -1203,21 +1218,21 @@ declare class PaymentAPI {
      *
      * @example
      * ```typescript
-     * const processor = moneymq.payment.processor();
+     * const stream = moneymq.payment.paymentStream();
      *
-     * processor.on('transaction', (tx) => {
-     *   const actor = tx.actor();
+     * stream.on('transaction', (tx) => {
+     *   const hook = tx.hook();
      *
-     *   actor.on('payment:settled', async (event) => {
+     *   hook.on('payment:settled', async (event) => {
      *     await processPayment(event.data);
-     *     await actor.send('order:completed', { orderId: tx.id });
+     *     await hook.attach('fulfillment', { orderId: tx.id });
      *   });
      * });
      *
-     * processor.connect();
+     * stream.connect();
      * ```
      */
-    processor(options?: ReceiverOptions): EventReceiver;
+    paymentStream(options?: PaymentStreamOptions): PaymentStream;
     /**
      * Create a payment listener (subscribe only)
      *
@@ -1268,7 +1283,34 @@ declare class PaymentAPI {
 }
 
 /**
- * MoneyMQ server configuration returned from /config endpoint
+ * Payment API configuration returned from /payment/v1/config endpoint
+ */
+interface PaymentConfig {
+    isSandbox: boolean;
+    x402: {
+        solana: {
+            payout: {
+                recipientAddress?: string;
+                recipientTokenAccount?: string;
+                tokenAddress: string;
+            };
+            facilitator: {
+                address?: string;
+            };
+        };
+    };
+    stack: {
+        name?: string;
+        imageUrl?: string;
+    };
+    studio?: {
+        rpcUrl?: string;
+        wsUrl?: string;
+    };
+}
+/**
+ * Legacy server configuration returned from /config endpoint
+ * @deprecated Use PaymentConfig and fetchPaymentConfig instead
  */
 interface ServerConfig {
     account: {
@@ -1304,20 +1346,29 @@ interface ServerConfig {
     };
 }
 /**
- * Fetch server configuration from MoneyMQ API
+ * Fetch payment configuration from MoneyMQ Payment API
  *
  * @param apiUrl - The MoneyMQ API URL
- * @returns Server configuration including RPC URL
+ * @param includeStudio - Include studio config (RPC/WS URLs)
+ * @returns Payment configuration
  *
  * @example
  * ```typescript
- * const config = await fetchConfig('http://localhost:8488');
- * console.log(config.x402.validator.rpcUrl);
+ * const config = await fetchPaymentConfig('http://localhost:8488', true);
+ * console.log(config.studio?.rpcUrl);
  * ```
  */
+declare function fetchPaymentConfig(apiUrl: string, includeStudio?: boolean): Promise<PaymentConfig>;
+/**
+ * Fetch server configuration from MoneyMQ API
+ * @deprecated Use fetchPaymentConfig instead
+ *
+ * @param apiUrl - The MoneyMQ API URL
+ * @returns Server configuration including RPC URL
+ */
 declare function fetchConfig(apiUrl: string): Promise<ServerConfig>;
 /**
- * Get the Solana RPC URL from server config
+ * Get the Solana RPC URL from payment config
  *
  * @param apiUrl - The MoneyMQ API URL
  * @param fallback - Fallback RPC URL if fetch fails
@@ -1376,7 +1427,7 @@ interface X402ClientConfig {
  */
 declare class X402API {
     private config;
-    private serverConfig;
+    private paymentConfig;
     private sandboxAccounts;
     constructor(config: MoneyMQConfig);
     /**
@@ -1408,60 +1459,13 @@ declare class X402API {
      */
     getConfig(): Promise<X402ClientConfig>;
     /**
-     * Get the full server configuration
+     * Get the full payment configuration
      *
-     * @returns The complete server configuration including x402 settings
+     * @returns The complete payment configuration including x402 settings
      */
-    getServerConfig(): Promise<ServerConfig>;
+    getPaymentConfig(): Promise<PaymentConfig>;
 }
 
-/**
- * Server-Sent Events (SSE) helpers for MoneyMQ real-time events
- *
- * Supports two modes:
- * - **Stateless**: Client tracks cursor, replay from memory on reconnect
- * - **Stateful**: Server tracks cursor in DB, guaranteed delivery on reconnect
- *
- * @example Stateless stream (client-side cursor)
- * ```typescript
- * import { MoneyMQ } from '@moneymq/sdk';
- *
- * const moneymq = new MoneyMQ({ endpoint: 'http://localhost:8488' });
- *
- * // Create a stateless event stream with replay
- * const stream = moneymq.events.stream({ last: 10 });
- *
- * stream.on('payment', (event) => {
- *   console.log('Payment event:', event.type, event.data);
- *   // Store cursor for reconnection
- *   localStorage.setItem('cursor', event.id);
- * });
- *
- * stream.connect();
- * ```
- *
- * @example Stateful stream (server-side cursor persistence)
- * ```typescript
- * import { MoneyMQ } from '@moneymq/sdk';
- *
- * const moneymq = new MoneyMQ({ endpoint: 'http://localhost:8488' });
- *
- * // Create a stateful stream - server tracks your position
- * // Use a unique, deterministic ID for your consumer
- * const stream = moneymq.events.stream({
- *   streamId: 'checkout-widget-user-123',
- * });
- *
- * stream.on('payment', (event) => {
- *   // Server automatically tracks cursor - no need to store locally
- *   console.log('Payment event:', event.type, event.data);
- * });
- *
- * stream.connect();
- *
- * // On reconnect, server replays missed events automatically
- * ```
- */
 /**
  * CloudEvent v1.0 specification envelope
  */
@@ -1558,10 +1562,32 @@ interface PaymentSettlementFailedData {
     /** Payment flow type (x402 or checkout) */
     payment_flow: PaymentFlow;
 }
+/**
+ * Transaction completed event data
+ * This is emitted when a transaction is fully complete (settled and all attachments received)
+ */
+interface TransactionCompletedData {
+    /** Transaction ID (payment_hash) */
+    transaction_id: string;
+    /** JWT receipt token containing payment claims */
+    receipt: string;
+    /** Wallet address of the payer */
+    payer: string;
+    /** Payment amount */
+    amount: string;
+    /** Currency code */
+    currency: string;
+    /** Network name */
+    network: string;
+    /** Transaction signature on-chain */
+    transaction_signature: string | null;
+    /** Product ID if applicable */
+    product_id: string | null;
+}
 /**
  * All MoneyMQ event types
  */
-type MoneyMQEventType = 'mq.money.payment.verification.succeeded' | 'mq.money.payment.verification.failed' | 'mq.money.payment.settlement.succeeded' | 'mq.money.payment.settlement.failed';
+type MoneyMQEventType = 'mq.money.payment.verification.succeeded' | 'mq.money.payment.verification.failed' | 'mq.money.payment.settlement.succeeded' | 'mq.money.payment.settlement.failed' | 'mq.money.transaction.completed';
 /**
  * Event type to data type mapping
  */
@@ -1570,6 +1596,7 @@ interface MoneyMQEventMap {
     'mq.money.payment.verification.failed': PaymentVerificationFailedData;
     'mq.money.payment.settlement.succeeded': PaymentSettlementSucceededData;
     'mq.money.payment.settlement.failed': PaymentSettlementFailedData;
+    'mq.money.transaction.completed': TransactionCompletedData;
 }
 /**
  * Payment verification event (succeeded or failed)
@@ -1579,10 +1606,14 @@ type PaymentVerificationEvent = CloudEventEnvelope<PaymentVerificationSucceededD
  * Payment settlement event (succeeded or failed)
  */
 type PaymentSettlementEvent = CloudEventEnvelope<PaymentSettlementSucceededData> | CloudEventEnvelope<PaymentSettlementFailedData>;
+/**
+ * Transaction completed event
+ */
+type TransactionCompletedEvent = CloudEventEnvelope<TransactionCompletedData>;
 /**
  * Any payment event
  */
-type PaymentEvent = PaymentVerificationEvent | PaymentSettlementEvent;
+type PaymentEvent = PaymentVerificationEvent | PaymentSettlementEvent | TransactionCompletedEvent;
 /**
  * Options for creating an event stream connection
  */
@@ -1772,6 +1803,10 @@ declare function isPaymentSettlementSucceeded(event: PaymentEvent): event is Clo
  * Check if an event is a payment settlement failed event
  */
 declare function isPaymentSettlementFailed(event: PaymentEvent): event is CloudEventEnvelope<PaymentSettlementFailedData>;
+/**
+ * Check if an event is a transaction completed event
+ */
+declare function isTransactionCompleted(event: PaymentEvent): event is CloudEventEnvelope<TransactionCompletedData>;
 /**
  * Parse a raw SSE data string into a CloudEvent
  *
@@ -1864,7 +1899,7 @@ declare class MoneyMQ {
     /** X402 API for agentic payments */
     readonly x402: X402API;
     /** Events API for real-time SSE streams
-     * @deprecated Use `payment.processor()` and `payment.listener()` instead
+     * @deprecated Use `payment.paymentStream()` and `payment.listener()` instead
      */
     readonly events: {
         /**
@@ -1874,21 +1909,21 @@ declare class MoneyMQ {
          */
         reader: (channelId: string, options?: ReaderOptions) => EventReader;
         /**
-         * Create an event actor (subscribe + publish)
+         * Create a payment hook (subscribe + publish)
          *
-         * @deprecated Use `payment.processor()` with `tx.actor()` instead
+         * @deprecated Use `payment.paymentStream()` with `tx.hook()` instead
          */
-        actor: (channelId: string, options?: ActorOptions) => EventActor;
+        hook: (channelId: string, options?: PaymentHookOptions) => PaymentHook;
         /**
-         * Create an event receiver (transaction spawner)
+         * Create a payment stream (transaction spawner)
          *
-         * @deprecated Use `payment.processor()` instead
+         * @deprecated Use `payment.paymentStream()` instead
          */
-        receiver: (options?: ReceiverOptions) => EventReceiver;
+        paymentStream: (options?: PaymentStreamOptions) => PaymentStream;
         /**
          * Create a new event stream connection
          *
-         * @deprecated Use `payment.processor()` instead
+         * @deprecated Use `payment.paymentStream()` instead
          */
         stream: (options?: EventStreamOptions) => EventStream;
     };
@@ -2085,4 +2120,4 @@ declare class CheckoutReceipt {
     };
 }
 
-export { type ActorOptions, type Attachments, type BasketItem, ChannelError, type ChannelErrorHandler, type ChannelEvent, type ChannelEventHandler, type ChannelStreamMessage, type CheckoutCreateParams, type CheckoutLineItem, CheckoutReceipt, type CheckoutSession, type CloudEventEnvelope, type ConnectionHandler, type ConnectionState, type Customer, type CustomerCreateParams, type CustomerUpdateParams, type ErrorHandler, type ErrorStreamMessage, EventActor, type EventHandler, EventReader, EventReceiver, EventStream, type EventStreamMessage, type EventStreamOptions, type EventStreamState, type ExperimentConfig, type GetSignerParams, MoneyMQ, type MoneyMQConfig, type MoneyMQEventMap, type MoneyMQEventType, type PayParams, type PayResult, type Payment, type PaymentDetails, type PaymentEvent, type PaymentFlow, type PaymentIntent, type PaymentIntentCreateParams, type PaymentLink, type PaymentLinkCreateParams, type PaymentListParams, PaymentRequiredError, type PaymentRequirements, type PaymentSettlementEvent, type PaymentSettlementFailedData, type PaymentSettlementSucceededData, type PaymentVerificationEvent, type PaymentVerificationFailedData, type PaymentVerificationSucceededData, type Payout, type PayoutCreateParams, type PayoutListParams, type PayoutSettings, type PayoutSettingsUpdateParams, type Price, type PriceCreateParams, type PriceRecurring, type ProcessorData, type Product, type ProductAccessParams, type ProductAccessResponse, type ProductCreateParams, type ProductFeature$1 as ProductFeature, type ProductListParams, type ProductPrice, type ReaderOptions, type ReceiptClaims, type ReceiverOptions, type ReceiverStreamMessage, type ServerConfig, type StateHandler, type StateStreamMessage, type StreamOptions, type Transaction, type TransactionHandler, type TransactionStreamMessage, type TransactionWithActor, type X402ClientConfig, buildEventStreamUrl, computeChannelId, createEventActor, createEventReader, createEventReceiver, createEventStream, fetchConfig, getRpcUrl, isPaymentSettlementFailed, isPaymentSettlementSucceeded, isPaymentVerificationFailed, isPaymentVerificationSucceeded, parseCloudEvent };
+export { type Attachments, type BasketItem, ChannelError, type ChannelErrorHandler, type ChannelEvent, type ChannelEventHandler, type ChannelStreamMessage, type CheckoutCreateParams, type CheckoutLineItem, CheckoutReceipt, type CheckoutSession, type CloudEventEnvelope, type ConnectionHandler, type ConnectionState, type Customer, type CustomerCreateParams, type CustomerUpdateParams, type ErrorHandler, type ErrorStreamMessage, type EventHandler, EventReader, EventStream, type EventStreamMessage, type EventStreamOptions, type EventStreamState, type ExperimentConfig, type GetSignerParams, MoneyMQ, type MoneyMQConfig, type MoneyMQEventMap, type MoneyMQEventType, type PayParams, type PayResult, type Payment, type PaymentConfig, type PaymentDetails, type PaymentEvent, type PaymentFlow, PaymentHook, type PaymentHookOptions, type PaymentIntent, type PaymentIntentCreateParams, type PaymentLink, type PaymentLinkCreateParams, type PaymentListParams, PaymentRequiredError, type PaymentRequirements, type PaymentSettlementEvent, type PaymentSettlementFailedData, type PaymentSettlementSucceededData, PaymentStream, type PaymentStreamOptions, type PaymentVerificationEvent, type PaymentVerificationFailedData, type PaymentVerificationSucceededData, type Payout, type PayoutCreateParams, type PayoutListParams, type PayoutSettings, type PayoutSettingsUpdateParams, type Price, type PriceCreateParams, type PriceRecurring, type ProcessorData, type Product, type ProductAccessParams, type ProductAccessResponse, type ProductCreateParams, type ProductFeature$1 as ProductFeature, type ProductListParams, type ProductPrice, type ReaderOptions, type ReceiptClaims, type ReceiverStreamMessage, type ServerConfig, type StateHandler, type StateStreamMessage, type StreamOptions, type Transaction, type TransactionCompletedData, type TransactionCompletedEvent, type TransactionHandler, type TransactionStreamMessage, type TransactionWithHook, type X402ClientConfig, buildEventStreamUrl, computeChannelId, createEventReader, createEventStream, createPaymentHook, createPaymentStream, fetchConfig, fetchPaymentConfig, getRpcUrl, isPaymentSettlementFailed, isPaymentSettlementSucceeded, isPaymentVerificationFailed, isPaymentVerificationSucceeded, isTransactionCompleted, parseCloudEvent };