@moneymq/sdk 0.3.2 → 0.7.0

package/dist/index.d.ts

@@ -1,3 +1,40 @@
+import { Signer } from 'x402-fetch';
+export { Signer } from 'x402-fetch';
+
+/** Payment requirements returned when payment is required (402) */
+interface PaymentRequirements {
+    scheme: string;
+    network: string;
+    max_amount_required: string;
+    resource: string;
+    description: string;
+    mime_type: string;
+    pay_to: string;
+    max_timeout_seconds: number;
+    asset: string;
+    extra?: {
+        feePayer?: string;
+        product?: string;
+    };
+}
+/** Error thrown when payment is required to access a resource */
+declare class PaymentRequiredError extends Error {
+    readonly paymentRequirements: PaymentRequirements[];
+    readonly raw: unknown;
+    constructor(message: string, paymentRequirements: PaymentRequirements[], raw: unknown);
+}
+/** Response from product access endpoint */
+interface ProductAccessResponse {
+    object: 'product_access';
+    product_id: string;
+    access_granted: boolean;
+    message: string;
+}
+/** Parameters for accessing a product with x402 payment */
+interface ProductAccessParams {
+    /** Base64-encoded X-Payment header value */
+    paymentHeader?: string;
+}
 interface Product {
     id: string;
     object: 'product';
@@ -7,6 +44,8 @@ interface Product {
     metadata?: Record<string, string>;
     created: number;
     updated: number;
+    /** URL path for accessing this product (x402 gated) */
+    accessUrl: string;
 }
 interface ProductCreateParams {
     name: string;
@@ -74,6 +113,32 @@ declare class ProductsAPI {
     delete(id: string): Promise<{
         deleted: boolean;
     }>;
+    /**
+     * Access a product - gated by x402 payment
+     *
+     * This endpoint requires payment. If no payment header is provided (or payment is invalid),
+     * throws a PaymentRequiredError with the payment requirements.
+     *
+     * @example
+     * ```ts
+     * try {
+     *   // First attempt without payment - will throw PaymentRequiredError
+     *   const access = await moneymq.catalog.products.access('surfnet-max');
+     * } catch (error) {
+     *   if (error instanceof PaymentRequiredError) {
+     *     // Get payment requirements and create payment
+     *     const requirements = error.paymentRequirements[0];
+     *     const paymentHeader = await createPayment(requirements);
+     *
+     *     // Retry with payment
+     *     const access = await moneymq.catalog.products.access('surfnet-max', {
+     *       paymentHeader,
+     *     });
+     *   }
+     * }
+     * ```
+     */
+    access(id: string, params?: ProductAccessParams): Promise<ProductAccessResponse>;
 }
 declare class PricesAPI {
     private config;
@@ -167,6 +232,60 @@ interface PaymentListParams {
     limit?: number;
     startingAfter?: string;
 }
+interface PayParams {
+    /** Amount in smallest currency unit (e.g., cents for USD) */
+    amount: number;
+    /** Currency code (e.g., 'usd', 'usdc') */
+    currency: string;
+    /** Product name for display */
+    productName: string;
+    /** Product ID for tracking */
+    productId?: string;
+    /** Optional product description */
+    description?: string;
+    /** Customer wallet address */
+    customer?: string;
+    /** Additional metadata */
+    metadata?: Record<string, string>;
+}
+interface PayResult {
+    /** Checkout session ID */
+    sessionId: string;
+    /** Payment intent ID */
+    paymentIntentId: string;
+    /** Client secret for confirming payment */
+    clientSecret: string;
+    /** Total amount in smallest currency unit */
+    amount: number;
+    /** Currency */
+    currency: string;
+    /** Status */
+    status: 'requires_confirmation' | 'succeeded' | 'failed';
+}
+interface PaymentIntent {
+    id: string;
+    object: 'payment_intent';
+    amount: number;
+    currency: string;
+    status: 'requires_payment_method' | 'requires_confirmation' | 'processing' | 'succeeded' | 'canceled';
+    customer?: string;
+    description?: string;
+    metadata: Record<string, string>;
+    clientSecret?: string;
+    created: number;
+}
+interface PaymentIntentCreateParams {
+    /** Amount in smallest currency unit */
+    amount: number;
+    /** Currency code */
+    currency: string;
+    /** Customer wallet address */
+    customer?: string;
+    /** Description */
+    description?: string;
+    /** Metadata including product info */
+    metadata?: Record<string, string>;
+}
 interface Customer {
     id: string;
     object: 'customer';
@@ -319,13 +438,41 @@ declare class WebhooksAPI {
         success: boolean;
     }>;
 }
+/**
+ * Payment Intents API - for direct payments without full checkout flow
+ * Similar to Stripe's Payment Intents API
+ */
+declare class PaymentIntentsAPI {
+    private request;
+    constructor(config: MoneyMQConfig);
+    /**
+     * Create a payment intent
+     * Use this for simple payments without the full checkout session flow
+     */
+    create(params: PaymentIntentCreateParams): Promise<PaymentIntent>;
+    /**
+     * Retrieve a payment intent
+     */
+    retrieve(id: string): Promise<PaymentIntent>;
+    /**
+     * Confirm a payment intent
+     * This triggers the actual payment (and x402 flow if required)
+     */
+    confirm(id: string): Promise<PaymentIntent>;
+    /**
+     * Cancel a payment intent
+     */
+    cancel(id: string): Promise<PaymentIntent>;
+}
 /**
  * Payment API for checkout, links, customers, and payouts
  */
 declare class PaymentAPI {
     private request;
-    /** Checkout sessions API */
+    /** Checkout sessions API - for full e-commerce flows with line items */
     readonly checkout: CheckoutAPI;
+    /** Payment intents API - for simpler direct payments */
+    readonly intents: PaymentIntentsAPI;
     /** Payment links API */
     readonly links: LinksAPI;
     /** Customers API */
@@ -335,6 +482,21 @@ declare class PaymentAPI {
     /** Webhooks API */
     readonly webhooks: WebhooksAPI;
     constructor(config: MoneyMQConfig);
+    /**
+     * Simple one-liner payment - creates a checkout session with inline product data
+     *
+     * @example
+     * ```ts
+     * const result = await moneymq.payment.pay({
+     *   amount: 999,
+     *   currency: 'usd',
+     *   productName: 'Pro Plan',
+     *   productId: 'pro-plan',
+     *   customer: 'wallet_address',
+     * });
+     * ```
+     */
+    pay(params: PayParams): Promise<PayResult>;
     /**
      * Retrieve a payment by ID
      */
@@ -348,6 +510,538 @@ declare class PaymentAPI {
     }>;
 }
 
+/**
+ * MoneyMQ server configuration returned from /config endpoint
+ */
+interface ServerConfig {
+    account: {
+        name: string;
+        description: string;
+    };
+    x402: {
+        payoutAccount: {
+            currency: string;
+            decimals: number;
+            address: string;
+            tokenAddress: string;
+        };
+        facilitator: {
+            operatorAccount: {
+                out: string;
+                in: {
+                    currency: string;
+                    decimals: number;
+                    address: string;
+                    tokenAddress: string;
+                };
+            };
+            url: string;
+        };
+        validator: {
+            network: string;
+            rpcUrl: string;
+            bindHost: string;
+            rpcPort: number;
+            wsPort: number;
+        };
+    };
+}
+/**
+ * Fetch server configuration from MoneyMQ API
+ *
+ * @param apiUrl - The MoneyMQ API URL
+ * @returns Server configuration including RPC URL
+ *
+ * @example
+ * ```typescript
+ * const config = await fetchConfig('http://localhost:8488');
+ * console.log(config.x402.validator.rpcUrl);
+ * ```
+ */
+declare function fetchConfig(apiUrl: string): Promise<ServerConfig>;
+/**
+ * Get the Solana RPC URL from server config
+ *
+ * @param apiUrl - The MoneyMQ API URL
+ * @param fallback - Fallback RPC URL if fetch fails
+ * @returns RPC URL string
+ */
+declare function getRpcUrl(apiUrl: string, fallback?: string): Promise<string>;
+
+/**
+ * Parameters for getting a signer by tag
+ */
+interface GetSignerParams {
+    /**
+     * Tag/label identifying the sandbox wallet account
+     * @example 'alice', 'bob', 'agent-1'
+     */
+    tag: string;
+}
+
+/**
+ * X402 configuration compatible with x402-fetch wrapFetchWithPayment
+ */
+interface X402ClientConfig {
+    svmConfig?: {
+        rpcUrl: string;
+    };
+}
+/**
+ * X402 API for agentic payments
+ *
+ * @example
+ * ```typescript
+ * import { wrapFetchWithPayment } from 'x402-fetch';
+ *
+ * const moneymq = new MoneyMQ({
+ *   endpoint: 'http://localhost:8488',
+ * });
+ *
+ * // Get signer for sandbox account by label
+ * const payer = await moneymq.x402.getSigner({ tag: 'alice' });
+ *
+ * // Get x402 config for the fetch wrapper
+ * const config = await moneymq.x402.getConfig();
+ *
+ * // Create the payment-enabled fetch
+ * const fetchWithPayment = wrapFetchWithPayment(
+ *   fetch,
+ *   payer,
+ *   undefined,
+ *   undefined,
+ *   config,
+ * );
+ *
+ * // Make requests that automatically handle 402 payments
+ * const response = await fetchWithPayment(url, { method: 'GET' });
+ * ```
+ */
+declare class X402API {
+    private config;
+    private serverConfig;
+    private sandboxAccounts;
+    constructor(config: MoneyMQConfig);
+    /**
+     * Fetch sandbox accounts from the server
+     */
+    private fetchSandboxAccounts;
+    /**
+     * Get a signer for a sandbox account by tag/label
+     *
+     * @param params - Parameters containing the wallet tag/label
+     * @returns A Signer that can be used directly with wrapFetchWithPayment
+     *
+     * @example
+     * ```typescript
+     * const payer = await moneymq.x402.getSigner({ tag: 'alice' });
+     * ```
+     */
+    getSigner(params: GetSignerParams): Promise<Signer>;
+    /**
+     * Get x402 configuration for use with wrapFetchWithPayment
+     *
+     * @returns Configuration object compatible with x402-fetch
+     *
+     * @example
+     * ```typescript
+     * const config = await moneymq.x402.getConfig();
+     * const fetchWithPayment = wrapFetchWithPayment(fetch, payer, undefined, undefined, config);
+     * ```
+     */
+    getConfig(): Promise<X402ClientConfig>;
+    /**
+     * Get the full server configuration
+     *
+     * @returns The complete server configuration including x402 settings
+     */
+    getServerConfig(): Promise<ServerConfig>;
+}
+
+/**
+ * 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
+ */
+interface CloudEventEnvelope<T = unknown> {
+    /** CloudEvents specification version */
+    specversion: string;
+    /** Unique event identifier (UUID) */
+    id: string;
+    /** Event type (e.g., 'mq.money.payment.verification.succeeded') */
+    type: string;
+    /** Event source URI */
+    source: string;
+    /** Timestamp in ISO 8601 format */
+    time: string;
+    /** Content type of the data field */
+    datacontenttype: string;
+    /** Event payload */
+    data: T;
+}
+/**
+ * Payment flow type - indicates how the payment was initiated
+ */
+type PaymentFlow = {
+    type: 'x402';
+} | {
+    type: 'checkout';
+    intent_id: string;
+};
+/**
+ * Payment verification succeeded event data
+ */
+interface PaymentVerificationSucceededData {
+    /** Wallet address of the payer */
+    payer: string;
+    /** Amount in smallest unit (e.g., lamports for SOL, micro-units for USDC) */
+    amount: string;
+    /** Network the payment was verified on */
+    network: string;
+    /** Product ID if available */
+    product_id: string | null;
+    /** Payment flow type (x402 or checkout) */
+    payment_flow: PaymentFlow;
+}
+/**
+ * Payment verification failed event data
+ */
+interface PaymentVerificationFailedData {
+    /** Wallet address of the payer if known */
+    payer: string | null;
+    /** Amount that was attempted */
+    amount: string;
+    /** Network the verification was attempted on */
+    network: string;
+    /** Reason for the failure */
+    reason: string;
+    /** Product ID if available */
+    product_id: string | null;
+    /** Payment flow type (x402 or checkout) */
+    payment_flow: PaymentFlow;
+}
+/**
+ * Payment settlement succeeded event data
+ */
+interface PaymentSettlementSucceededData {
+    /** Wallet address of the payer */
+    payer: string;
+    /** Amount in smallest unit (e.g., lamports for SOL, micro-units for USDC) */
+    amount: string;
+    /** Network the transaction occurred on */
+    network: string;
+    /** Transaction signature/hash if available */
+    transaction_signature: string | null;
+    /** Product ID if available */
+    product_id: string | null;
+    /** Payment flow type (x402 or checkout) */
+    payment_flow: PaymentFlow;
+}
+/**
+ * Payment settlement failed event data
+ */
+interface PaymentSettlementFailedData {
+    /** Wallet address of the payer if known */
+    payer: string | null;
+    /** Amount that was attempted */
+    amount: string;
+    /** Network the settlement was attempted on */
+    network: string;
+    /** Reason for the failure */
+    reason: string;
+    /** Product ID if available */
+    product_id: string | null;
+    /** Payment flow type (x402 or checkout) */
+    payment_flow: PaymentFlow;
+}
+/**
+ * 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';
+/**
+ * Event type to data type mapping
+ */
+interface MoneyMQEventMap {
+    'mq.money.payment.verification.succeeded': PaymentVerificationSucceededData;
+    'mq.money.payment.verification.failed': PaymentVerificationFailedData;
+    'mq.money.payment.settlement.succeeded': PaymentSettlementSucceededData;
+    'mq.money.payment.settlement.failed': PaymentSettlementFailedData;
+}
+/**
+ * Payment verification event (succeeded or failed)
+ */
+type PaymentVerificationEvent = CloudEventEnvelope<PaymentVerificationSucceededData> | CloudEventEnvelope<PaymentVerificationFailedData>;
+/**
+ * Payment settlement event (succeeded or failed)
+ */
+type PaymentSettlementEvent = CloudEventEnvelope<PaymentSettlementSucceededData> | CloudEventEnvelope<PaymentSettlementFailedData>;
+/**
+ * Any payment event
+ */
+type PaymentEvent = PaymentVerificationEvent | PaymentSettlementEvent;
+/**
+ * Options for creating an event stream connection
+ */
+interface EventStreamOptions {
+    /**
+     * Replay the last N events before switching to live
+     * @example { last: 10 } - Replay last 10 events
+     */
+    last?: number;
+    /**
+     * Resume from a specific event ID (exclusive)
+     * Events after this ID will be replayed, then live events
+     * @example { cursor: 'abc-123-def' }
+     */
+    cursor?: string;
+    /**
+     * Stateful stream ID for server-side cursor persistence
+     *
+     * When provided, the server tracks the last consumed event for this stream.
+     * On reconnection, missed events are automatically replayed from where you left off.
+     *
+     * Use a deterministic ID unique to your consumer (e.g., 'checkout-widget-123').
+     *
+     * @example { streamId: 'my-checkout-widget' }
+     */
+    streamId?: string;
+    /**
+     * Automatically reconnect on connection loss
+     * @default true
+     */
+    autoReconnect?: boolean;
+    /**
+     * Delay between reconnection attempts in milliseconds
+     * @default 1000
+     */
+    reconnectDelay?: number;
+    /**
+     * Maximum number of reconnection attempts (0 = infinite)
+     * @default 0
+     */
+    maxReconnectAttempts?: number;
+}
+/**
+ * Event stream connection state
+ */
+type EventStreamState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/**
+ * Event handler callback type
+ */
+type EventHandler<T = PaymentEvent> = (event: T) => void;
+/**
+ * Error handler callback type
+ */
+type ErrorHandler = (error: Error) => void;
+/**
+ * State change handler callback type
+ */
+type StateHandler = (state: EventStreamState) => void;
+/**
+ * MoneyMQ Event Stream client for receiving real-time purchase events
+ *
+ * @example
+ * ```typescript
+ * const stream = new EventStream('http://localhost:8488', { last: 5 });
+ *
+ * stream.on('payment', (event) => {
+ *   console.log('Payment event:', event.type);
+ *   // Store cursor for reconnection
+ *   localStorage.setItem('cursor', event.id);
+ * });
+ *
+ * stream.on('error', (error) => {
+ *   console.error('Stream error:', error);
+ * });
+ *
+ * stream.on('stateChange', (state) => {
+ *   console.log('Connection state:', state);
+ * });
+ *
+ * stream.connect();
+ *
+ * // Later: disconnect
+ * stream.disconnect();
+ * ```
+ */
+declare class EventStream {
+    private endpoint;
+    private options;
+    private eventSource;
+    private state;
+    private reconnectAttempts;
+    private lastEventId;
+    private paymentHandlers;
+    private errorHandlers;
+    private stateHandlers;
+    constructor(endpoint: string, options?: EventStreamOptions);
+    /**
+     * Whether this is a stateful stream (server tracks cursor)
+     */
+    get isStateful(): boolean;
+    /**
+     * The stream ID for stateful streams
+     */
+    get streamId(): string | null;
+    /**
+     * Current connection state
+     */
+    get connectionState(): EventStreamState;
+    /**
+     * Current cursor (last received event ID)
+     */
+    get cursor(): string | null;
+    /**
+     * Whether the stream is currently connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Register an event handler
+     *
+     * @param event - Event type: 'payment', 'error', or 'stateChange'
+     * @param handler - Callback function
+     * @returns Unsubscribe function
+     */
+    on(event: 'payment', handler: EventHandler): () => void;
+    on(event: 'error', handler: ErrorHandler): () => void;
+    on(event: 'stateChange', handler: StateHandler): () => void;
+    /**
+     * Remove an event handler
+     */
+    off(event: 'payment', handler: EventHandler): void;
+    off(event: 'error', handler: ErrorHandler): void;
+    off(event: 'stateChange', handler: StateHandler): void;
+    /**
+     * Connect to the event stream
+     */
+    connect(): void;
+    /**
+     * Disconnect from the event stream
+     */
+    disconnect(): void;
+    /**
+     * Reconnect with a new cursor
+     * Useful for resuming from a stored position
+     */
+    reconnectFrom(cursor: string): void;
+    private buildUrl;
+    private setState;
+    private shouldReconnect;
+    private scheduleReconnect;
+    private emitPayment;
+    private emitError;
+}
+/**
+ * Create an event stream connection
+ *
+ * @param endpoint - MoneyMQ API endpoint
+ * @param options - Stream options (cursor, replay count, etc.)
+ * @returns EventStream instance
+ *
+ * @example
+ * ```typescript
+ * // Live events only
+ * const stream = createEventStream('http://localhost:8488');
+ *
+ * // Replay last 10 events
+ * const stream = createEventStream('http://localhost:8488', { last: 10 });
+ *
+ * // Resume from cursor
+ * const cursor = localStorage.getItem('lastEventId');
+ * const stream = createEventStream('http://localhost:8488', { cursor });
+ * ```
+ */
+declare function createEventStream(endpoint: string, options?: EventStreamOptions): EventStream;
+/**
+ * Check if an event is a payment verification succeeded event
+ */
+declare function isPaymentVerificationSucceeded(event: PaymentEvent): event is CloudEventEnvelope<PaymentVerificationSucceededData>;
+/**
+ * Check if an event is a payment verification failed event
+ */
+declare function isPaymentVerificationFailed(event: PaymentEvent): event is CloudEventEnvelope<PaymentVerificationFailedData>;
+/**
+ * Check if an event is a payment settlement succeeded event
+ */
+declare function isPaymentSettlementSucceeded(event: PaymentEvent): event is CloudEventEnvelope<PaymentSettlementSucceededData>;
+/**
+ * Check if an event is a payment settlement failed event
+ */
+declare function isPaymentSettlementFailed(event: PaymentEvent): event is CloudEventEnvelope<PaymentSettlementFailedData>;
+/**
+ * Parse a raw SSE data string into a CloudEvent
+ *
+ * @param data - Raw event data string from SSE
+ * @returns Parsed CloudEvent or null if parsing fails
+ */
+declare function parseCloudEvent(data: string): PaymentEvent | null;
+/**
+ * Build an event stream URL with query parameters
+ *
+ * @param endpoint - MoneyMQ API endpoint
+ * @param options - Stream options
+ * @returns Full URL string
+ *
+ * @example
+ * ```typescript
+ * const url = buildEventStreamUrl('http://localhost:8488', { last: 10 });
+ * // Returns: 'http://localhost:8488/events?last=10'
+ *
+ * const url = buildEventStreamUrl('http://localhost:8488', { cursor: 'abc' });
+ * // Returns: 'http://localhost:8488/events?cursor=abc'
+ *
+ * // Stateful stream (server tracks cursor):
+ * const url = buildEventStreamUrl('http://localhost:8488', { streamId: 'my-stream' });
+ * // Returns: 'http://localhost:8488/events?stream_id=my-stream'
+ * ```
+ */
+declare function buildEventStreamUrl(endpoint: string, options?: Pick<EventStreamOptions, 'last' | 'cursor' | 'streamId'>): string;
+
 /**
  * Configuration options for the MoneyMQ client
  *
@@ -408,6 +1102,28 @@ declare class MoneyMQ {
     readonly catalog: CatalogAPI;
     /** Payment API for checkout, links, customers, and payouts */
     readonly payment: PaymentAPI;
+    /** X402 API for agentic payments */
+    readonly x402: X402API;
+    /** Events API for real-time SSE streams */
+    readonly events: {
+        /**
+         * Create a new event stream connection
+         *
+         * @example
+         * ```typescript
+         * const stream = moneymq.events.stream({ last: 10 });
+         *
+         * stream.on('payment', (event) => {
+         *   console.log('Payment event:', event.type);
+         * });
+         *
+         * stream.connect();
+         * ```
+         */
+        stream: (options?: EventStreamOptions) => EventStream;
+    };
+    /** MoneyMQ API endpoint */
+    get endpoint(): string;
     constructor(config: MoneyMQConfig);
     /**
      * Make an authenticated request to the MoneyMQ API
@@ -415,62 +1131,4 @@ declare class MoneyMQ {
     request<T>(method: 'GET' | 'POST' | 'PUT' | 'DELETE', path: string, body?: unknown): Promise<T>;
 }
 
-/**
- * MoneyMQ server configuration returned from /config endpoint
- */
-interface ServerConfig {
-    account: {
-        name: string;
-        description: string;
-    };
-    x402: {
-        payoutAccount: {
-            currency: string;
-            decimals: number;
-            address: string;
-            tokenAddress: string;
-        };
-        facilitator: {
-            operatorAccount: {
-                out: string;
-                in: {
-                    currency: string;
-                    decimals: number;
-                    address: string;
-                    tokenAddress: string;
-                };
-            };
-            url: string;
-        };
-        validator: {
-            network: string;
-            rpcUrl: string;
-            bindHost: string;
-            rpcPort: number;
-            wsPort: number;
-        };
-    };
-}
-/**
- * Fetch server configuration from MoneyMQ API
- *
- * @param apiUrl - The MoneyMQ API URL
- * @returns Server configuration including RPC URL
- *
- * @example
- * ```typescript
- * const config = await fetchConfig('http://localhost:8488');
- * console.log(config.x402.validator.rpcUrl);
- * ```
- */
-declare function fetchConfig(apiUrl: string): Promise<ServerConfig>;
-/**
- * Get the Solana RPC URL from server config
- *
- * @param apiUrl - The MoneyMQ API URL
- * @param fallback - Fallback RPC URL if fetch fails
- * @returns RPC URL string
- */
-declare function getRpcUrl(apiUrl: string, fallback?: string): Promise<string>;
-
-export { type CheckoutCreateParams, type CheckoutSession, type Customer, type CustomerCreateParams, type CustomerUpdateParams, MoneyMQ, type MoneyMQConfig, type Payment, type PaymentLink, type PaymentLinkCreateParams, type PaymentListParams, type Payout, type PayoutCreateParams, type PayoutListParams, type PayoutSettings, type PayoutSettingsUpdateParams, type Price, type PriceCreateParams, type Product, type ProductCreateParams, type ProductListParams, type ServerConfig, fetchConfig, getRpcUrl };
+export { type CheckoutCreateParams, type CheckoutSession, type CloudEventEnvelope, type Customer, type CustomerCreateParams, type CustomerUpdateParams, type ErrorHandler, type EventHandler, EventStream, type EventStreamOptions, type EventStreamState, type GetSignerParams, MoneyMQ, type MoneyMQConfig, type MoneyMQEventMap, type MoneyMQEventType, type PayParams, type PayResult, type Payment, 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 Product, type ProductAccessParams, type ProductAccessResponse, type ProductCreateParams, type ProductListParams, type ServerConfig, type StateHandler, type X402ClientConfig, buildEventStreamUrl, createEventStream, fetchConfig, getRpcUrl, isPaymentSettlementFailed, isPaymentSettlementSucceeded, isPaymentVerificationFailed, isPaymentVerificationSucceeded, parseCloudEvent };