@solvapay/react 1.0.9-preview.1 → 1.0.9

package/dist/index-WBjulQHf.d.cts

@@ -0,0 +1,3656 @@
+import * as _stripe_stripe_js from '@stripe/stripe-js';
+import { PaymentIntent } from '@stripe/stripe-js';
+import { AuthAdapter } from './adapters/auth.cjs';
+
+interface components {
+    schemas: {
+        SdkMerchantResponseDto: {
+            /**
+             * Brand name shown in UI
+             * @example Acme
+             */
+            displayName: string;
+            /**
+             * Legal entity name used in SCA mandate copy
+             * @example Acme Inc.
+             */
+            legalName: string;
+            /** @example support@acme.com */
+            supportEmail?: string;
+            /** @example https://acme.com/support */
+            supportUrl?: string;
+            /** @example https://acme.com/terms */
+            termsUrl?: string;
+            /** @example https://acme.com/privacy */
+            privacyUrl?: string;
+            /**
+             * ISO-3166 alpha-2 country code of the merchant
+             * @example US
+             */
+            country?: string;
+            /**
+             * ISO-4217 default settlement currency
+             * @example usd
+             */
+            defaultCurrency?: string;
+            /**
+             * Descriptor appearing on the customer card statement
+             * @example ACME INC
+             */
+            statementDescriptor?: string;
+            /**
+             * Absolute URL to the merchant logo
+             * @example https://cdn.acme.com/logo.png
+             */
+            logoUrl?: string;
+            /**
+             * Absolute URL to the square app icon / logomark. Consumed by MCP host chromes, mobile avatar slots, and any surface where the landscape `logoUrl` would need letterboxing.
+             * @example https://cdn.acme.com/icon.png
+             */
+            iconUrl?: string;
+        };
+        SdkPlatformConfigResponseDto: {
+            /**
+             * SolvaPay's platform Stripe publishable key for the authenticated provider's environment. Safe to expose browser-side; paired with the connected `accountId` returned from `create-payment-intent` for Stripe Connect direct charges. Omitted when not configured so callers can fall back cleanly to a hosted flow.
+             * @example pk_test_...
+             */
+            stripePublishableKey?: string;
+        };
+        CreatePaymentIntentDto: {
+            productRef?: string;
+            customerRef: string;
+            planRef?: string;
+            pricingTier?: string;
+            /**
+             * @default product
+             * @enum {string}
+             */
+            purpose: "product" | "credit_topup" | "usage_billing";
+            amount?: number;
+            currency?: string;
+            description?: string;
+        };
+        CreateCheckoutSessionRequest: {
+            customerRef: string;
+            productRef?: string;
+            planRef?: string;
+            returnUrl?: string;
+            /** @enum {string} */
+            purpose?: "credit_topup";
+        };
+        CancelPurchaseRequest: {
+            reason?: string;
+        };
+        ProcessPaymentIntentDto: {
+            productRef: string;
+            customerRef: string;
+            planRef?: string;
+        };
+        CreateCheckoutSessionResponse: {
+            /**
+             * Checkout session ID/token
+             * @example e3f1c2d4b6a89f001122334455667788
+             */
+            sessionId: string;
+            /**
+             * Full checkout URL based on backend configuration (ready to redirect customer)
+             * @example https://solvapay.com/customer/checkout?id=e3f1c2d4b6a89f001122334455667788
+             */
+            checkoutUrl: string;
+        };
+        Plan: {
+            /**
+             * Plan type exposed in SDK
+             * @example recurring
+             * @enum {string}
+             */
+            type: "recurring" | "one-time" | "usage-based" | "hybrid";
+            /**
+             * Plan reference
+             * @example pln_1A2B3C4D
+             */
+            reference: string;
+            /**
+             * Meter reference for usage-based plans
+             * @example mtr_1A2B3C4D
+             */
+            meterRef?: string;
+            /**
+             * Plan name
+             * @example Starter
+             */
+            name?: string;
+            /**
+             * Plan description
+             * @example Best for teams getting started
+             */
+            description?: string;
+            /**
+             * Plan price in cents
+             * @example 2999
+             */
+            price: number;
+            /**
+             * Currency code (ISO 4217)
+             * @example USD
+             */
+            currency: string;
+            /**
+             * Currency symbol (derived from currency)
+             * @example $
+             */
+            currencySymbol?: string;
+            /**
+             * Number of free units included
+             * @example 100
+             */
+            freeUnits?: number;
+            /**
+             * One-time setup fee
+             * @example 500
+             */
+            setupFee?: number;
+            /**
+             * Free trial period in days
+             * @example 14
+             */
+            trialDays?: number;
+            /**
+             * Billing cycle
+             * @example monthly
+             */
+            billingCycle?: string;
+            /**
+             * Billing model
+             * @example pre-paid
+             * @enum {string}
+             */
+            billingModel?: "pre-paid" | "post-paid";
+            /**
+             * Credits per usage unit (integer, >= 1)
+             * @example 1
+             */
+            creditsPerUnit?: number;
+            /**
+             * What the plan measures for usage tracking
+             * @example requests
+             */
+            measures?: string;
+            /**
+             * Usage limit for the meter
+             * @example 10000
+             */
+            limit?: number;
+            /**
+             * Whether unused units roll over to next period
+             * @example false
+             */
+            rolloverUnusedUnits?: boolean;
+            /** @description Usage limits */
+            limits?: {
+                [key: string]: unknown;
+            };
+            /** @description Plan features */
+            features?: {
+                [key: string]: unknown;
+            };
+            /**
+             * Whether payment is required
+             * @example true
+             */
+            requiresPayment: boolean;
+            /**
+             * Whether the plan is active (derived from status)
+             * @example true
+             */
+            isActive: boolean;
+            /** @description Maximum number of active users */
+            maxActiveUsers?: number;
+            /** @description Access expiry in days */
+            accessExpiryDays?: number;
+            /**
+             * Plan status
+             * @example active
+             */
+            status: string;
+            /** @description Creation timestamp */
+            createdAt: string;
+            /** @description Last update timestamp */
+            updatedAt: string;
+        };
+        CreatePlanRequest: {
+            name?: string;
+            description?: string;
+            /** @enum {string} */
+            type?: "recurring" | "usage-based" | "one-time" | "hybrid";
+            /** @enum {string} */
+            billingCycle?: "weekly" | "monthly" | "quarterly" | "yearly" | "custom";
+            price?: number;
+            creditsPerUnit?: number;
+            currency?: string;
+            /** @enum {string} */
+            billingModel?: "pre-paid" | "post-paid";
+            freeUnits?: number;
+            limit?: number;
+            basePrice?: number;
+            setupFee?: number;
+            trialDays?: number;
+            rolloverUnusedUnits?: boolean;
+            autoRenew?: boolean;
+            usageTracking: {
+                /** @enum {string} */
+                method?: "automatic" | "manual" | "hybrid";
+                /** @enum {string} */
+                granularity?: "hourly" | "daily" | "weekly" | "monthly";
+            };
+            limits: {
+                [key: string]: unknown;
+            };
+            metadata: {
+                [key: string]: unknown;
+            };
+            features: {
+                [key: string]: unknown;
+            };
+            /** @enum {string} */
+            status?: "active" | "inactive" | "archived";
+            maxActiveUsers?: number;
+            accessExpiryDays?: number;
+            default?: boolean;
+        };
+        UpdatePlanRequest: {
+            name?: string;
+            description?: string;
+            /** @enum {string} */
+            billingCycle?: "weekly" | "monthly" | "quarterly" | "yearly" | "custom";
+            price?: number;
+            creditsPerUnit?: number;
+            currency?: string;
+            /** @enum {string} */
+            billingModel?: "pre-paid" | "post-paid";
+            freeUnits?: number;
+            limit?: number;
+            limits: {
+                [key: string]: unknown;
+            };
+            features: {
+                [key: string]: unknown;
+            };
+            /** @enum {string} */
+            status?: "active" | "inactive" | "archived";
+            maxActiveUsers?: number;
+            accessExpiryDays?: number;
+            metadata: {
+                [key: string]: unknown;
+            };
+            default?: boolean;
+        };
+        CreateProductRequest: {
+            name: string;
+            description?: string;
+            imageUrl?: string;
+            productType?: string;
+            isMcpPay?: boolean;
+            config: {
+                fulfillmentType?: string;
+                validityPeriod?: number;
+                deliveryMethod?: string;
+            };
+            metadata: {
+                [key: string]: unknown;
+            };
+        };
+        ProductConfigDto: {
+            /**
+             * Fulfillment type
+             * @example digital
+             */
+            fulfillmentType?: string;
+            /**
+             * Validity period in days
+             * @example 30
+             */
+            validityPeriod?: number;
+            /**
+             * Delivery method
+             * @example api
+             */
+            deliveryMethod?: string;
+        };
+        SdkPlanResponse: {
+            /**
+             * Plan reference
+             * @example pln_1A2B3C4D
+             */
+            reference: string;
+            /**
+             * Plan price in cents
+             * @example 2999
+             */
+            price: number;
+            /**
+             * Currency code (ISO 4217)
+             * @example USD
+             */
+            currency: string;
+            /**
+             * Currency symbol
+             * @example $
+             */
+            currencySymbol?: string;
+            /**
+             * One-time setup fee
+             * @example 500
+             */
+            setupFee?: number;
+            /**
+             * Free trial period in days
+             * @example 14
+             */
+            trialDays?: number;
+            /**
+             * Billing cycle
+             * @example monthly
+             */
+            billingCycle?: string;
+            /**
+             * Billing model
+             * @example pre-paid
+             */
+            billingModel?: string;
+            /**
+             * Credits per usage unit (integer, >= 1)
+             * @example 1
+             */
+            creditsPerUnit?: number;
+            /**
+             * What the plan measures for usage tracking
+             * @example requests
+             */
+            measures?: string;
+            /**
+             * Meter reference for usage-based limits
+             * @example mtr_1A2B3C4D
+             */
+            meterRef?: string;
+            /**
+             * Usage limit for the meter
+             * @example 10000
+             */
+            limit?: number;
+            /**
+             * Whether unused units roll over to next period
+             * @example false
+             */
+            rolloverUnusedUnits?: boolean;
+            /**
+             * Included free units
+             * @example 1000
+             */
+            freeUnits?: number;
+            /** @description Usage limits */
+            limits?: {
+                [key: string]: unknown;
+            };
+            /** @description Plan features */
+            features?: {
+                [key: string]: unknown;
+            };
+            /**
+             * Whether payment is required
+             * @example true
+             */
+            requiresPayment: boolean;
+            /**
+             * Whether the plan is active
+             * @example true
+             */
+            isActive: boolean;
+            /**
+             * Plan status
+             * @example active
+             */
+            status: string;
+            /** @description Creation timestamp */
+            createdAt: string;
+            /** @description Last update timestamp */
+            updatedAt: string;
+        };
+        SdkProductResponse: {
+            /**
+             * Product reference
+             * @example prd_1A2B3C4D
+             */
+            reference: string;
+            /**
+             * Product name
+             * @example AI Writing Assistant
+             */
+            name: string;
+            /** @description Product description */
+            description?: string;
+            /** @description URL to the product image */
+            imageUrl?: string;
+            /** @description Free-form product type */
+            productType?: string;
+            /**
+             * Product status
+             * @example active
+             */
+            status: string;
+            /**
+             * Product balance in cents
+             * @example 0
+             */
+            balance: number;
+            /**
+             * Total number of transactions
+             * @example 0
+             */
+            totalTransactions: number;
+            /**
+             * Whether this product uses MCP Pay proxy
+             * @example false
+             */
+            isMcpPay: boolean;
+            /** @description Product-specific configuration */
+            config?: components["schemas"]["ProductConfigDto"];
+            /** @description Arbitrary key-value metadata */
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /** @description Creation timestamp */
+            createdAt: string;
+            /** @description Last update timestamp */
+            updatedAt: string;
+            /** @description Plans associated with this product */
+            plans?: components["schemas"]["SdkPlanResponse"][];
+            /**
+             * MCP linkage details for MCP-enabled products
+             * @example {
+             *       "mcpServerRef": "mcp_ABC123",
+             *       "mcpSubdomain": "acme-docs",
+             *       "mcpProxyUrl": "https://acme-docs.mcp.solvapay.com/mcp",
+             *       "originUrl": "https://origin.example.com/mcp",
+             *       "defaultPlanRef": "pln_FREE123"
+             *     }
+             */
+            mcp?: {
+                [key: string]: unknown;
+            };
+        };
+        UpdateProductRequest: {
+            name?: string;
+            description?: string;
+            imageUrl?: string;
+            productType?: string;
+            /** @enum {string} */
+            status?: "active" | "inactive" | "suspended";
+            config: {
+                fulfillmentType?: string;
+                validityPeriod?: number;
+                deliveryMethod?: string;
+            };
+            metadata: {
+                [key: string]: unknown;
+            };
+        };
+        McpBootstrapDto: {
+            name?: string;
+            description?: string;
+            imageUrl?: string;
+            productType?: string;
+            /** Format: uri */
+            originUrl: string;
+            mcpDomain?: string;
+            authHeaderName?: string;
+            authApiKey?: string;
+            plans?: {
+                key: string;
+                name: string;
+                price: number;
+                currency: string;
+                /** @enum {string} */
+                billingCycle?: "weekly" | "monthly" | "quarterly" | "yearly" | "custom";
+                /** @enum {string} */
+                type?: "recurring" | "one-time" | "usage-based";
+                creditsPerUnit?: number;
+                /** @enum {string} */
+                billingModel?: "pre-paid" | "post-paid";
+                freeUnits?: number;
+                limit?: number;
+                features?: {
+                    [key: string]: unknown;
+                };
+            }[];
+            tools?: {
+                name: string;
+                description?: string;
+                noPlan?: boolean;
+                planKeys?: string[];
+            }[];
+            metadata: {
+                [key: string]: unknown;
+            };
+        };
+        McpBootstrapResult: {
+            /** @description Created product */
+            product: components["schemas"]["SdkProductResponse"];
+            /**
+             * Created or updated MCP server identity
+             * @example {
+             *       "reference": "mcp_ABC123",
+             *       "subdomain": "acme-docs",
+             *       "mcpProxyUrl": "https://acme-docs.mcp.solvapay.com/mcp",
+             *       "url": "https://origin.example.com/mcp",
+             *       "defaultPlanRef": "pln_FREE123"
+             *     }
+             */
+            mcpServer: {
+                [key: string]: unknown;
+            };
+            /**
+             * Resolved plan mapping by bootstrap key
+             * @example {
+             *       "free": {
+             *         "reference": "pln_FREE123",
+             *         "name": "Free"
+             *       }
+             *     }
+             */
+            planMap: {
+                [key: string]: unknown;
+            };
+            /**
+             * True when tools were auto-discovered from origin because the request omitted tools
+             * @example true
+             */
+            toolsAutoMapped?: boolean;
+            /** @description Auto-discovered tools used during bootstrap */
+            autoMappedTools?: {
+                name?: string;
+                description?: string;
+            }[];
+        };
+        ConfigureMcpPlansDto: {
+            plans?: {
+                key: string;
+                name: string;
+                price: number;
+                currency: string;
+                /** @enum {string} */
+                billingCycle?: "weekly" | "monthly" | "quarterly" | "yearly" | "custom";
+                /** @enum {string} */
+                type?: "recurring" | "one-time" | "usage-based";
+                creditsPerUnit?: number;
+                /** @enum {string} */
+                billingModel?: "pre-paid" | "post-paid";
+                freeUnits?: number;
+                limit?: number;
+                features?: {
+                    [key: string]: unknown;
+                };
+            }[];
+            toolMapping?: {
+                name: string;
+                planKeys: string[];
+            }[];
+        };
+        ConfigureMcpPlansResult: {
+            /** @description Updated product */
+            product: components["schemas"]["SdkProductResponse"];
+            /** @description Updated MCP server identity */
+            mcpServer: {
+                [key: string]: unknown;
+            };
+            /** @description Resolved plan mapping by key (includes existing free plan) */
+            planMap: {
+                [key: string]: unknown;
+            };
+        };
+        CloneProductDto: {
+            name?: string;
+        };
+        CreateUsageRequest: {
+            customerRef: string;
+            /**
+             * @default api_call
+             * @enum {string}
+             */
+            actionType: "transaction" | "api_call" | "hour" | "email" | "storage" | "custom";
+            /** @default 1 */
+            units: number;
+            /**
+             * @default success
+             * @enum {string}
+             */
+            outcome: "success" | "paywall" | "fail";
+            productRef?: string;
+            purchaseRef?: string;
+            description?: string;
+            errorMessage?: string;
+            metadata: {
+                [key: string]: unknown;
+            };
+            duration?: number;
+            /** Format: date-time */
+            timestamp: string;
+            idempotencyKey?: string;
+        };
+        BulkCreateUsageRequest: {
+            events: {
+                customerRef: string;
+                /**
+                 * @default api_call
+                 * @enum {string}
+                 */
+                actionType: "transaction" | "api_call" | "hour" | "email" | "storage" | "custom";
+                /** @default 1 */
+                units: number;
+                /**
+                 * @default success
+                 * @enum {string}
+                 */
+                outcome: "success" | "paywall" | "fail";
+                productRef?: string;
+                purchaseRef?: string;
+                description?: string;
+                errorMessage?: string;
+                metadata?: {
+                    [key: string]: unknown;
+                };
+                duration?: number;
+                /** Format: date-time */
+                timestamp: string;
+                idempotencyKey?: string;
+            }[];
+        };
+        RecordMeterEventZodDto: {
+            meterName: string;
+            customerRef: string;
+            value?: number;
+            properties: {
+                [key: string]: unknown;
+            };
+            productRef?: string;
+            timestamp?: string;
+        };
+        RecordBulkMeterEventsZodDto: {
+            events: {
+                meterName: string;
+                customerRef: string;
+                value?: number;
+                properties?: {
+                    [key: string]: unknown;
+                };
+                productRef?: string;
+                timestamp?: string;
+            }[];
+        };
+        UsageBillingDto: {
+            /**
+             * Units consumed in current period
+             * @example 150
+             */
+            used: number;
+            /**
+             * Units exceeding the plan limit
+             * @example 0
+             */
+            overageUnits: number;
+            /**
+             * Overage cost in cents
+             * @example 0
+             */
+            overageCost: number;
+            /**
+             * Period start date
+             * @example 2025-10-01T00:00:00Z
+             */
+            periodStart?: string;
+            /**
+             * Period end date
+             * @example 2025-11-01T00:00:00Z
+             */
+            periodEnd?: string;
+        };
+        SdkPlanSnapshotDto: {
+            /**
+             * Plan reference
+             * @example pln_1A2B3C4D
+             */
+            reference?: string;
+            /**
+             * Plan price in cents
+             * @example 2999
+             */
+            price: number;
+            /**
+             * Currency code
+             * @example USD
+             */
+            currency: string;
+            /**
+             * Plan type
+             * @example recurring
+             */
+            planType: string;
+            /**
+             * Billing cycle
+             * @example monthly
+             */
+            billingCycle?: string | null;
+            /** @description Plan features */
+            features?: {
+                [key: string]: unknown;
+            } | null;
+            /** @description Usage limits */
+            limits?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * Meter reference
+             * @example mtr_1A2B3C4D
+             */
+            meterRef?: string;
+            /**
+             * Usage limit for the meter
+             * @example 5000
+             */
+            limit?: number;
+            /**
+             * Number of free units included
+             * @example 100
+             */
+            freeUnits?: number;
+            /**
+             * Credits per usage unit (integer, >= 1)
+             * @example 1
+             */
+            creditsPerUnit?: number;
+        };
+        SdkPurchaseResponse: {
+            /**
+             * Purchase reference
+             * @example pur_1A2B3C4D
+             */
+            reference: string;
+            /**
+             * Customer reference
+             * @example cus_3C4D5E6F
+             */
+            customerRef: string;
+            /**
+             * Customer email
+             * @example customer@example.com
+             */
+            customerEmail: string;
+            /**
+             * Product reference
+             * @example prd_1A2B3C4D
+             */
+            productRef: string;
+            /**
+             * Product name
+             * @example API Gateway Manager
+             */
+            productName?: string;
+            /** @description Plan snapshot at time of purchase (null for credit topups) */
+            planSnapshot?: components["schemas"]["SdkPlanSnapshotDto"];
+            /**
+             * Purchase status
+             * @example active
+             */
+            status: string;
+            /**
+             * Amount in USD cents (normalised for aggregation)
+             * @example 9900
+             */
+            amount: number;
+            /**
+             * Original amount in the payment currency (cents/pence)
+             * @example 10000
+             */
+            originalAmount?: number;
+            /**
+             * Original payment currency code
+             * @example GBP
+             */
+            currency: string;
+            /**
+             * Exchange rate from original currency to USD
+             * @example 1.3082
+             */
+            exchangeRate?: number;
+            /** @description Start date */
+            startDate: string;
+            /** @description End date */
+            endDate?: string;
+            /** @description Paid at timestamp */
+            paidAt?: string;
+            /** @description Usage billing state for usage-based plans */
+            usage?: components["schemas"]["UsageBillingDto"];
+            /**
+             * Is recurring
+             * @example true
+             */
+            isRecurring: boolean;
+            /**
+             * Billing cycle
+             * @enum {string}
+             */
+            billingCycle?: "weekly" | "monthly" | "quarterly" | "yearly";
+            /** @description Next billing date */
+            nextBillingDate?: string;
+            /** @description Auto-renew enabled */
+            autoRenew?: boolean;
+            /** @description Cancelled at */
+            cancelledAt?: string;
+            /** @description Cancellation reason */
+            cancellationReason?: string;
+            /** @description Arbitrary metadata attached to the purchase */
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /** @description Created at */
+            createdAt: string;
+        };
+        CheckLimitRequest: {
+            customerRef: string;
+            productRef: string;
+            meterName?: string;
+            usageType?: string;
+        };
+        LimitPlanItemDto: {
+            reference: string;
+            name?: string;
+            type: string;
+            /** @description Price in smallest currency unit (e.g. cents) */
+            price: number;
+            currency: string;
+            requiresPayment: boolean;
+            freeUnits?: number;
+            /** @description Credits per usage unit (usage-based plans) */
+            creditsPerUnit?: number;
+            billingModel?: string;
+            billingCycle?: string;
+        };
+        LimitBalanceDto: {
+            /** @description Credit balance in mils */
+            creditBalance: number;
+            /** @description Credits per usage unit */
+            creditsPerUnit: number;
+            currency: string;
+            /** @description Estimated whole units remaining from prepaid credit balance */
+            remainingUnits?: number;
+        };
+        LimitProductBriefDto: {
+            reference: string;
+            name?: string;
+        };
+        LimitResponse: {
+            /**
+             * Whether the customer is within their usage limits
+             * @example true
+             */
+            withinLimits: boolean;
+            /**
+             * Remaining usage units before hitting the limit
+             * @example 997
+             */
+            remaining: number;
+            /**
+             * Checkout session ID if payment is required
+             * @example e3f1c2d4b6a89f001122334455667788
+             */
+            checkoutSessionId?: string;
+            /**
+             * Checkout URL if payment is required
+             * @example https://solvapay.com/customer/checkout?id=e3f1c2d4b6a89f001122334455667788
+             */
+            checkoutUrl?: string;
+            /**
+             * The meter name to use when tracking usage events
+             * @example requests
+             */
+            meterName?: string;
+            /** @description Credit balance in mils (for pre-paid usage-based plans) */
+            creditBalance?: number;
+            /** @description Credits per usage unit (for pre-paid usage-based plans) */
+            creditsPerUnit?: number;
+            /** @description ISO 4217 currency code for credit fields */
+            currency?: string;
+            /** @description True when the customer must activate a priced default plan before usage is allowed */
+            activationRequired?: boolean;
+            /** @description Active plans on the product available for activation or checkout */
+            plans?: components["schemas"]["LimitPlanItemDto"][];
+            /** @description Prepaid usage balance context when the default plan is usage-based */
+            balance?: components["schemas"]["LimitBalanceDto"];
+            /** @description Product the limit check applies to */
+            product?: components["schemas"]["LimitProductBriefDto"];
+            /** @description Customer portal confirmation URL when activation is required (fallback when not starting checkout) */
+            confirmationUrl?: string;
+        };
+        ActivatePlanDto: {
+            customerRef: string;
+            productRef: string;
+            planRef: string;
+        };
+        ActivatePlanResponseDto: {
+            /** @enum {string} */
+            status: "activated" | "already_active" | "topup_required" | "payment_required" | "invalid";
+            purchaseRef?: string;
+            message?: string;
+            creditBalance?: number;
+            creditsPerUnit?: number;
+            currency?: string;
+            checkoutUrl?: string;
+            checkoutSessionId?: string;
+        };
+        CreateCustomerRequest: {
+            /** Format: email */
+            email: string;
+            name?: string;
+            telephone?: string;
+            metadata: {
+                [key: string]: unknown;
+            };
+            externalRef?: string;
+        };
+        CreateCustomerSessionRequest: {
+            customerRef: string;
+            productRef?: string;
+        };
+        PurchaseInfo: {
+            /**
+             * Purchase reference
+             * @example pur_1A2B3C4D
+             */
+            reference: string;
+            /**
+             * Product name
+             * @example API Gateway Manager
+             */
+            productName: string;
+            /**
+             * Product reference
+             * @example prd_abc123
+             */
+            productRef?: string;
+            /**
+             * Purchase status
+             * @example active
+             */
+            status: string;
+            /**
+             * Start date
+             * @example 2025-10-27T10:00:00Z
+             */
+            startDate: string;
+            /**
+             * Amount in USD cents (normalised for aggregation)
+             * @example 9900
+             */
+            amount: number;
+            /**
+             * Original amount in the payment currency (minor units)
+             * @example 7500
+             */
+            originalAmount?: number;
+            /**
+             * ISO 4217 currency code of the customer-facing charge
+             * @example GBP
+             */
+            currency: string;
+            /**
+             * Exchange rate from original currency to USD
+             * @example 1.32
+             */
+            exchangeRate?: number;
+            /**
+             * End date of purchase
+             * @example 2025-11-27T10:00:00Z
+             */
+            endDate?: string;
+            /**
+             * When purchase was cancelled
+             * @example 2025-10-28T10:00:00Z
+             */
+            cancelledAt?: string;
+            /**
+             * Reason for cancellation
+             * @example Customer request
+             */
+            cancellationReason?: string;
+            /**
+             * Plan reference from the plan snapshot, for reliable plan matching
+             * @example pln_abc123
+             */
+            planRef?: string;
+            /** @description Snapshot of the plan at time of purchase */
+            planSnapshot?: Record<string, never>;
+        };
+        CustomerResponse: {
+            /**
+             * Customer reference identifier
+             * @example cus_3c4d5e6f7g8h
+             */
+            reference: string;
+            /**
+             * Customer full name
+             * @example John Doe
+             */
+            name: string;
+            /**
+             * Customer email address
+             * @example customer@example.com
+             */
+            email: string;
+            /**
+             * External reference ID from your auth system (if set during creation or update)
+             * @example auth_user_12345
+             */
+            externalRef?: string;
+            /** @description Active purchases */
+            purchases?: components["schemas"]["PurchaseInfo"][];
+        };
+        UpdateCustomerRequest: {
+            /** Format: email */
+            email?: string;
+            name?: string;
+            telephone?: string;
+            metadata?: unknown;
+            externalRef?: string;
+        };
+        CreateCustomerSessionResponse: {
+            /**
+             * Customer session ID/token
+             * @example e3f1c2d4b6a89f001122334455667788
+             */
+            sessionId: string;
+            /**
+             * Full customer URL based on backend configuration (ready to redirect customer)
+             * @example https://solvapay.com/customer/manage?id=e3f1c2d4b6a89f001122334455667788
+             */
+            customerUrl: string;
+        };
+        GetCustomerSessionResponse: {
+            /**
+             * Customer session ID/token
+             * @example e3f1c2d4b6a89f001122334455667788
+             */
+            sessionId: string;
+            /**
+             * Session status
+             * @example active
+             * @enum {string}
+             */
+            status: "active" | "expired" | "used";
+            /**
+             * Full customer URL based on backend configuration (ready to redirect customer)
+             * @example https://solvapay.com/customer/manage?id=e3f1c2d4b6a89f001122334455667788
+             */
+            customerUrl: string;
+            /**
+             * Session expiration date
+             * @example 2025-01-01T12:00:00.000Z
+             */
+            expiresAt: string;
+            /** @description Customer object from session data */
+            customer: components["schemas"]["CustomerResponse"];
+            /**
+             * Session creation date
+             * @example 2025-01-01T11:45:00.000Z
+             */
+            createdAt: string;
+            /**
+             * Session last update date
+             * @example 2025-01-01T11:45:00.000Z
+             */
+            updatedAt: string;
+        };
+        UserInfoRequest: {
+            customerRef: string;
+            productRef: string;
+        };
+        UserInfoUserDto: {
+            /** @example cus_3C4D5E6F */
+            reference: string;
+            /** @example John Doe */
+            name?: string | null;
+            /** @example john@example.com */
+            email: string;
+            /** @example auth_user_12345 */
+            externalRef?: string | null;
+        };
+        UserInfoUsageDto: {
+            /** @example 1000 */
+            total: number;
+            /** @example 250 */
+            used: number;
+            /** @example 750 */
+            remaining: number;
+            /**
+             * Meter reference
+             * @example meter_ABC123
+             */
+            meterRef?: string | null;
+            /** @example 25 */
+            percentUsed?: number | null;
+        };
+        UserInfoPlanDto: {
+            /** @example pln_2B3C4D5E */
+            reference: string;
+            /**
+             * Price in minor currency units (e.g. cents)
+             * @example 2999
+             */
+            price: number;
+            /** @example USD */
+            currency: string;
+            /** @example recurring */
+            type: string;
+            /** @example monthly */
+            billingCycle?: string | null;
+            features?: string[] | null;
+            limits?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        UserInfoPurchaseDto: {
+            /** @example pur_1A2B3C4D */
+            reference: string;
+            /** @example active */
+            status: string;
+            /** @example My API Product */
+            productName: string;
+            /** @example recurring */
+            planType: string;
+            /** @example 2025-10-27T10:00:00Z */
+            startDate?: string | null;
+            /** @example 2025-11-27T10:00:00Z */
+            endDate?: string | null;
+            usage?: components["schemas"]["UserInfoUsageDto"];
+            plan?: components["schemas"]["UserInfoPlanDto"];
+        };
+        UserInfoResponse: {
+            /**
+             * Human-readable status summary
+             * @example Active subscription: My API Product (25% usage consumed)
+             */
+            status: string;
+            /**
+             * Customer portal session URL
+             * @example https://solvapay.com/customer/manage?id=abc123
+             */
+            verifyUrl?: string | null;
+            user?: components["schemas"]["UserInfoUserDto"];
+            purchase?: components["schemas"]["UserInfoPurchaseDto"];
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    getMerchant: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Merchant identity */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkMerchantResponseDto"];
+                };
+            };
+            /** @description Provider not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getPlatformConfig: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Platform config */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkPlatformConfigResponseDto"];
+                };
+            };
+        };
+    };
+    PaymentIntentSdkController_getPaymentIntents: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of results */
+                limit?: number;
+                /** @description Pagination offset */
+                offset?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Payment intents retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    PaymentIntentSdkController_createPaymentIntent: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Unique idempotency key to prevent duplicate payments (required) */
+                "idempotency-key": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Payment intent creation data */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreatePaymentIntentDto"];
+            };
+        };
+        responses: {
+            /** @description Payment intent created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Missing required fields or invalid data */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    PaymentIntentSdkController_getPaymentIntent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Payment intent reference or processor payment ID */
+                reference: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Payment intent retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Payment intent not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    PaymentIntentSdkController_processPaymentIntent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Payment processor ID returned from createPaymentIntent */
+                processorPaymentId: string;
+            };
+            cookie?: never;
+        };
+        /** @description Payment processing data */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ProcessPaymentIntentDto"];
+            };
+        };
+        responses: {
+            /** @description Payment intent status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * Payment intent status
+                         * @example succeeded
+                         * @enum {string}
+                         */
+                        status?: "succeeded" | "timeout" | "failed" | "cancelled";
+                        /**
+                         * Optional message, only present for timeout status
+                         * @example Timeout while waiting for payment intent confirmation, try again later. This could be due to payment webhooks not being configured correctly.
+                         */
+                        message?: string;
+                    };
+                };
+            };
+            /** @description Payment not succeeded, invalid request, or forbidden */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    CheckoutSessionSdkController_createCheckoutSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateCheckoutSessionRequest"];
+            };
+        };
+        responses: {
+            /** @description Checkout session created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateCheckoutSessionResponse"];
+                };
+            };
+            /** @description Missing customerRef or productRef */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PlanSdkController_listPlans: {
+        parameters: {
+            query?: {
+                limit?: number;
+                offset?: number;
+            };
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Plans retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        plans?: components["schemas"]["Plan"][];
+                        /** @description Total number of plans for the product */
+                        total?: number;
+                        limit?: number;
+                        offset?: number;
+                    };
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PlanSdkController_createPlan: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreatePlanRequest"];
+            };
+        };
+        responses: {
+            /** @description Plan created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Plan"];
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PlanSdkController_getPlan: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+                /** @description Plan reference or ID */
+                planRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Plan retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Plan"];
+                };
+            };
+            /** @description Plan or product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PlanSdkController_updatePlan: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+                /** @description Plan reference or ID */
+                planRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdatePlanRequest"];
+            };
+        };
+        responses: {
+            /** @description Plan updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Plan"];
+                };
+            };
+            /** @description Plan or product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PlanSdkController_deletePlan: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+                /** @description Plan reference or ID */
+                planRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Plan deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Plan or product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_listProducts: {
+        parameters: {
+            query?: {
+                /** @description Max results (1-100) */
+                limit?: number;
+                /** @description Pagination offset */
+                offset?: number;
+                /** @description Search by name or description */
+                search?: string;
+                /** @description Filter by status */
+                status?: "active" | "inactive" | "suspended";
+                /** @description Filter MCP Pay products */
+                isMcpPay?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Products retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_createProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateProductRequest"];
+            };
+        };
+        responses: {
+            /** @description Product created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkProductResponse"];
+                };
+            };
+            /** @description Missing required fields or validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_getProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Product retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkProductResponse"];
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_updateProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateProductRequest"];
+            };
+        };
+        responses: {
+            /** @description Product updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkProductResponse"];
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_deleteProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Product deleted or deactivated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_bootstrapMcpProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["McpBootstrapDto"];
+            };
+        };
+        responses: {
+            /** @description MCP product bootstrapped successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["McpBootstrapResult"];
+                };
+            };
+            /** @description Invalid bootstrap request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_configureMcpPlans: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ConfigureMcpPlansDto"];
+            };
+        };
+        responses: {
+            /** @description MCP plans configured successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ConfigureMcpPlansResult"];
+                };
+            };
+            /** @description Invalid MCP plans request or product is not MCP-enabled */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ProductSdkController_cloneProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID to clone */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CloneProductDto"];
+            };
+        };
+        responses: {
+            /** @description Product cloned successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkProductResponse"];
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    UsageSdkController_recordUsage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateUsageRequest"];
+            };
+        };
+        responses: {
+            /** @description Usage recorded successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @example true */
+                        success?: boolean;
+                        /** @example usage_A1B2C3D4 */
+                        reference?: string;
+                    };
+                };
+            };
+            /** @description Validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    UsageSdkController_recordBulkUsage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BulkCreateUsageRequest"];
+            };
+        };
+        responses: {
+            /** @description Bulk usage events processed */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    MeterEventsSdkController_recordEvent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecordMeterEventZodDto"];
+            };
+        };
+        responses: {
+            /** @description Event recorded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @example true */
+                        success?: boolean;
+                    };
+                };
+            };
+            /** @description Invalid meter name or meter is archived */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    MeterEventsSdkController_recordBulkEvents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecordBulkMeterEventsZodDto"];
+            };
+        };
+        responses: {
+            /** @description Events recorded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @example true */
+                        success?: boolean;
+                        /** @example 50 */
+                        inserted?: number;
+                    };
+                };
+            };
+            /** @description Invalid meter name or meter is archived */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PurchaseSdkController_listPurchases: {
+        parameters: {
+            query?: {
+                /** @description Filter by purchase status */
+                status?: "pending" | "active" | "trialing" | "past_due" | "cancelled" | "expired" | "suspended" | "refunded";
+                /** @description Filter by product reference */
+                productRef?: string;
+                /** @description Filter by customer reference */
+                customerRef?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Purchases retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        purchases?: components["schemas"]["SdkPurchaseResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    PurchaseSdkController_getPurchasesForCustomer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Customer reference or ID */
+                customerRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer purchases retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        purchases?: components["schemas"]["SdkPurchaseResponse"][];
+                    };
+                };
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PurchaseSdkController_getPurchasesForProduct: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Product reference or ID */
+                productRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Product purchases retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        purchases?: components["schemas"]["SdkPurchaseResponse"][];
+                    };
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PurchaseSdkController_getPurchase: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Purchase reference or ID */
+                purchaseRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Purchase retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkPurchaseResponse"];
+                };
+            };
+            /** @description Purchase not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PurchaseSdkController_cancelPurchase: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Purchase reference or ID */
+                purchaseRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CancelPurchaseRequest"];
+            };
+        };
+        responses: {
+            /** @description Purchase cancelled successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success?: boolean;
+                        purchase?: components["schemas"]["SdkPurchaseResponse"];
+                    };
+                };
+            };
+            /** @description Purchase not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PurchaseSdkController_reactivatePurchase: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Purchase reference or ID */
+                purchaseRef: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Purchase reactivated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success?: boolean;
+                        purchase?: components["schemas"]["SdkPurchaseResponse"];
+                    };
+                };
+            };
+            /** @description Purchase cannot be reactivated */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Purchase not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    LimitsSdkController_checkLimits: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CheckLimitRequest"];
+            };
+        };
+        responses: {
+            /** @description Limit check result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LimitResponse"];
+                };
+            };
+            /** @description Missing customerRef or productRef */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Customer or product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ActivateSdkController_activate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ActivatePlanDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ActivatePlanResponseDto"];
+                };
+            };
+        };
+    };
+    CustomerSdkController_getCustomerByQuery: {
+        parameters: {
+            query?: {
+                /** @description Customer reference identifier (use exactly one query parameter) */
+                reference?: string;
+                /** @description External reference ID from your auth system (use exactly one query parameter) */
+                externalRef?: string;
+                /** @description Customer email address (use exactly one query parameter) */
+                email?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerResponse"];
+                };
+            };
+            /** @description Invalid request - must provide exactly one of reference, externalRef, or email */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    CustomerSdkController_createCustomer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Customer creation data */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateCustomerRequest"];
+            };
+        };
+        responses: {
+            /** @description Customer created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerResponse"];
+                };
+            };
+            /** @description Invalid email or missing required fields */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    CustomerSdkController_getCustomer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Customer reference identifier */
+                reference: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerResponse"];
+                };
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    CustomerSdkController_updateCustomer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Customer reference identifier */
+                reference: string;
+            };
+            cookie?: never;
+        };
+        /** @description Fields to update (all optional) */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateCustomerRequest"];
+            };
+        };
+        responses: {
+            /** @description Customer updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerResponse"];
+                };
+            };
+            /** @description Invalid update payload */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    CustomerSdkController_getCustomerBalance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Customer reference identifier */
+                reference: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer balance retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    CustomerSdkController_createCustomerSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Customer session creation request data */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateCustomerSessionRequest"];
+            };
+        };
+        responses: {
+            /** @description Customer session created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateCustomerSessionResponse"];
+                };
+            };
+            /** @description Invalid request data or customer not found */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    CustomerSdkController_getCustomerSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Customer session ID/token */
+                sessionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer session retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetCustomerSessionResponse"];
+                };
+            };
+            /** @description Customer session not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    UserInfoSdkController_getUserInfo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UserInfoRequest"];
+            };
+        };
+        responses: {
+            /** @description User info with purchase status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserInfoResponse"];
+                };
+            };
+            /** @description Missing customerRef or productRef */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Customer or product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PaymentMethodSdkController_getPaymentMethod: {
+        parameters: {
+            query: {
+                /** @description Customer reference (e.g. `customer_...`). */
+                customerRef: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The customer's default card, or `{ kind: 'none' }` when no card is on file. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        kind: "card";
+                        /** @example visa */
+                        brand: string;
+                        /** @example 4242 */
+                        last4: string;
+                        /** @example 12 */
+                        expMonth: number;
+                        /** @example 2030 */
+                        expYear: number;
+                    } | {
+                        /** @enum {string} */
+                        kind: "none";
+                    };
+                };
+            };
+        };
+    };
+}
+
+/**
+ * SolvaPay API Client Type Definitions
+ *
+ * Types related to the SolvaPay API client and backend communication.
+ */
+
+/**
+ * One-time purchase information returned from payment processing
+ */
+interface OneTimePurchaseInfo {
+    reference: string;
+    productRef?: string;
+    amount: number;
+    currency: string;
+    creditsAdded?: number;
+    completedAt: string;
+}
+/**
+ * Result from processing a payment intent
+ */
+interface ProcessPaymentResult {
+    type: 'recurring' | 'one-time';
+    purchase?: components['schemas']['PurchaseInfo'];
+    oneTimePurchase?: OneTimePurchaseInfo;
+    status: 'completed';
+}
+type ActivatePlanResult = components['schemas']['ActivatePlanResponseDto'];
+/**
+ * SDK-facing payment-method projection returned by
+ * `GET /v1/sdk/payment-method?customerRef=...`.
+ *
+ * Derived from the generated operation response so any backend shape
+ * change propagates through a single `npm run generate:types` run. The
+ * inline `oneOf` schema on the backend controller translates to a clean
+ * `{ kind: 'card', ... } | { kind: 'none' }` discriminated union here.
+ */
+type PaymentMethodInfo = operations['PaymentMethodSdkController_getPaymentMethod']['responses']['200']['content']['application/json'];
+
+/**
+ * Paywall Type Definitions
+ *
+ * Types related to paywall protection, limits, and gating functionality.
+ */
+
+type LimitPlanSummary = components['schemas']['LimitPlanItemDto'];
+type LimitActivationBalance = components['schemas']['LimitBalanceDto'];
+type LimitActivationProduct = components['schemas']['LimitProductBriefDto'];
+/**
+ * Structured content for paywall errors (MCP structuredContent and manual handling).
+ */
+type PaywallStructuredContent = {
+    kind: 'payment_required';
+    /** Product ref from paywall metadata (or env default) */
+    product: string;
+    checkoutUrl: string;
+    message: string;
+    /**
+     * Quota balance at the moment the paywall tripped. Optional so
+     * older server versions (pre-balance-on-payment_required) stay
+     * compatible; the React `PaywallNotice.Message` prefers this
+     * structured data over the raw `message` when available.
+     */
+    balance?: LimitActivationBalance;
+    /** Rich product context from checkLimits (name, ref, provider slug/id) */
+    productDetails?: LimitActivationProduct;
+} | {
+    kind: 'activation_required';
+    /** Product ref from paywall metadata (or env default) */
+    product: string;
+    message: string;
+    /**
+     * Best URL for completing purchase or confirmation; mirrors confirmationUrl when present.
+     */
+    checkoutUrl: string;
+    confirmationUrl?: string;
+    plans?: LimitPlanSummary[];
+    balance?: LimitActivationBalance;
+    /** Rich product context from checkLimits (name, ref, provider slug/id) */
+    productDetails?: LimitActivationProduct;
+};
+
+/**
+ * Customer Helper (Core)
+ *
+ * Generic helper for syncing customers with SolvaPay backend.
+ * Works with standard Web API Request (works everywhere).
+ */
+
+type CustomerBalanceResult = {
+    customerRef: string;
+    credits: number;
+    displayCurrency: string;
+    creditsPerMinorUnit: number;
+    displayExchangeRate: number;
+};
+
+interface PurchaseCheckResult {
+    customerRef: string;
+    email?: string;
+    name?: string;
+    purchases: Array<{
+        reference: string;
+        productName?: string;
+        productRef?: string;
+        status?: string;
+        startDate?: string;
+        planSnapshot?: {
+            meterId?: string;
+            limit?: number;
+            freeUnits?: number;
+        };
+        usage?: {
+            used?: number;
+            overageUnits?: number;
+            overageCost?: number;
+            periodStart?: string;
+            periodEnd?: string;
+        };
+        [key: string]: unknown;
+    }>;
+}
+
+/**
+ * Usage snapshot derived from the authenticated customer's active purchase.
+ *
+ * Shape matches the backend's `UserInfoUsageDto` so the React `useUsage`
+ * hook gets a canonical set of fields regardless of transport.
+ */
+interface GetUsageResult {
+    meterRef: string | null;
+    total: number | null;
+    used: number;
+    remaining: number | null;
+    /** 0–100, rounded to 2dp. `null` when `total` is unknown. */
+    percentUsed: number | null;
+    periodStart?: string;
+    periodEnd?: string;
+    /** Raw purchase ref the usage belongs to (when a usage-based plan is active). */
+    purchaseRef?: string;
+}
+
+/**
+ * Typed copy bundle surfaced through `<SolvaPayProvider config={{ copy }} />`.
+ *
+ * Every user-visible string in `@solvapay/react` routes through this bundle via
+ * `useCopy()`. Values are either plain templates with `{placeholder}` tokens or
+ * function-form resolvers (currently only used for mandate variants) that
+ * receive a `MandateContext` and return the final string.
+ */
+type MandateContext = {
+    merchant: {
+        legalName: string;
+        displayName?: string;
+        supportEmail?: string;
+        termsUrl?: string;
+        privacyUrl?: string;
+    };
+    plan?: {
+        name?: string;
+        interval?: string;
+        intervalCount?: number;
+        trialDays?: number;
+        measures?: string;
+        billingCycle?: string;
+    };
+    product?: {
+        name?: string;
+    };
+    amountFormatted: string;
+    trialDays?: number;
+};
+type MandateTemplate = string | ((ctx: MandateContext) => string);
+interface SolvaPayCopy {
+    mandate: {
+        recurring: MandateTemplate;
+        oneTime: MandateTemplate;
+        topup: MandateTemplate;
+        usageMetered: MandateTemplate;
+        freeTier: MandateTemplate;
+    };
+    cta: {
+        payNow: string;
+        topUp: string;
+        subscribe: string;
+        trialStart: string;
+        payAmount: string;
+        addAmount: string;
+        startUsing: string;
+        processing: string;
+    };
+    interval: {
+        day: string;
+        week: string;
+        month: string;
+        year: string;
+        every: string;
+        free: string;
+        trial: string;
+    };
+    terms: {
+        checkboxLabel: string;
+    };
+    customer: {
+        chargingTo: string;
+        emailLabel: string;
+        nameLabel: string;
+    };
+    balance: {
+        credits: string;
+        currencyEquivalent: string;
+    };
+    product: {
+        currentProductLabel: string;
+    };
+    topup: {
+        selectOrEnterAmount: string;
+        minAmount: string;
+        maxAmount: string;
+    };
+    activation: {
+        paymentRequired: string;
+        invalidConfiguration: string;
+        unexpectedResponse: string;
+        failed: string;
+    };
+    planSelector: {
+        heading: string;
+        currentBadge: string;
+        popularBadge: string;
+        freeBadge: string;
+        perIntervalShort: string;
+        continueButton: string;
+        backButton: string;
+        trialBadge: string;
+    };
+    amountPicker: {
+        selectAmountLabel: string;
+        customAmountLabel: string;
+        creditEstimateExact: string;
+        creditEstimateApprox: string;
+    };
+    activationFlow: {
+        heading: string;
+        activateButton: string;
+        activatingLabel: string;
+        topupHeading: string;
+        topupSubheading: string;
+        continueToPayment: string;
+        changeAmountButton: string;
+        retryingHeading: string;
+        retryingSubheading: string;
+        activatedHeading: string;
+        activatedSubheading: string;
+        tryAgainButton: string;
+        backButton: string;
+    };
+    cancelPlan: {
+        button: string;
+        buttonLoading: string;
+        confirmRecurring: string;
+        confirmUsageBased: string;
+    };
+    cancelledNotice: {
+        heading: string;
+        expiresLabel: string;
+        daysRemaining: string;
+        dayRemaining: string;
+        accessUntil: string;
+        accessEnded: string;
+        cancelledOn: string;
+        reactivateButton: string;
+        reactivateButtonLoading: string;
+    };
+    creditGate: {
+        lowBalanceHeading: string;
+        lowBalanceSubheading: string;
+        topUpCta: string;
+    };
+    currentPlan: {
+        heading: string;
+        nextBilling: string;
+        expiresOn: string;
+        validIndefinitely: string;
+        paymentMethod: string;
+        paymentMethodExpires: string;
+        noPaymentMethod: string;
+        updatePaymentButton: string;
+        /**
+         * Human-readable unit names for `billingCycle`, used as the `interval`
+         * arg to `formatPrice` so a monthly SEK plan renders "500 kr / month"
+         * rather than "500 kr / monthly".
+         */
+        cycleUnit: {
+            weekly: string;
+            monthly: string;
+            quarterly: string;
+            yearly: string;
+        };
+    };
+    customerPortal: {
+        launchButton: string;
+        loadingLabel: string;
+    };
+    errors: {
+        paymentInitFailed: string;
+        topupInitFailed: string;
+        configMissingPlanOrProduct: string;
+        configMissingAmount: string;
+        unknownError: string;
+        stripeUnavailable: string;
+        paymentIntentUnavailable: string;
+        cardElementMissing: string;
+        paymentUnexpected: string;
+        paymentProcessingFailed: string;
+        paymentRequires3ds: string;
+        paymentProcessingTimeout: string;
+        paymentConfirmationDelayed: string;
+        paymentStatusPrefix: string;
+        paywallInvalidContent: string;
+        usageLoadFailed: string;
+    };
+    paywall: {
+        header: string;
+        paymentRequiredHeading: string;
+        activationRequiredHeading: string;
+        resolvedHeading: string;
+        productContext: string;
+        balanceLine: string;
+        paymentRequiredMessage: string;
+        paymentRequiredMessageRemaining: string;
+        paymentRequiredProductSuffix: string;
+        retryButton: string;
+        hostedCheckoutButton: string;
+        hostedCheckoutLoading: string;
+    };
+    usage: {
+        header: string;
+        percentUsedLabel: string;
+        usedLabel: string;
+        remainingLabel: string;
+        unlimitedLabel: string;
+        resetsInLabel: string;
+        resetsOnLabel: string;
+        loadingLabel: string;
+        emptyLabel: string;
+        approachingLimit: string;
+        atLimit: string;
+        topUpCta: string;
+        upgradeCta: string;
+        refreshCta: string;
+    };
+}
+/**
+ * Deep-partial type for consumer overrides — every nested key is optional so
+ * integrators can override only the strings they care about.
+ */
+type PartialSolvaPayCopy = {
+    [K in keyof SolvaPayCopy]?: Partial<SolvaPayCopy[K]>;
+};
+
+/**
+ * Unified data-access surface for `@solvapay/react`.
+ *
+ * By default, `SolvaPayProvider` builds an HTTP transport from `config.api` +
+ * `config.fetch`. Integrators who need to route those calls somewhere else
+ * (e.g. an MCP host tunnelling through `app.callServerTool`) pass a
+ * `transport` on the provider config, replacing every call at once.
+ *
+ * See `@solvapay/react/mcp` for the canonical non-HTTP implementation.
+ */
+
+interface TransportBalanceResult {
+    credits: number;
+    displayCurrency: string;
+    creditsPerMinorUnit: number;
+    displayExchangeRate: number;
+}
+interface TransportCheckoutSessionResult {
+    checkoutUrl: string;
+}
+interface TransportCustomerSessionResult {
+    customerUrl: string;
+}
+/**
+ * Every method is required. Transports that can't honour a method should
+ * throw `UnsupportedTransportMethodError` from that method so callers can
+ * feature-detect with `catch (err) { if (err instanceof UnsupportedTransportMethodError) ... }`.
+ *
+ * For the MCP adapter, this is usually unnecessary: `app.callServerTool`
+ * already returns a structured error when the server doesn't expose the
+ * tool, and the adapter propagates that straight through.
+ */
+interface SolvaPayTransport {
+    /**
+     * Read tools. HTTP transports implement these via `GET /api/*` routes.
+     * MCP adapters omit them because the data is delivered on the
+     * bootstrap payload (see `BootstrapPayload.customer` / `merchant` /
+     * `product` / `plans` in `@solvapay/mcp`). Hooks consume these via
+     * module-level caches that the MCP host seeds at mount time, so the
+     * transport path is only exercised on HTTP.
+     */
+    checkPurchase?: () => Promise<CustomerPurchaseData>;
+    getBalance?: () => Promise<TransportBalanceResult>;
+    getMerchant?: () => Promise<Merchant>;
+    getProduct?: (productRef: string) => Promise<Product>;
+    listPlans?: (productRef: string) => Promise<Plan[]>;
+    /**
+     * Fetch the customer's default payment method for rendering under
+     * `<CurrentPlanCard>`. Returns `{ kind: 'none' }` when no card is on
+     * file — the SDK treats both that and a throw as "hide the section".
+     * HTTP transports implement via `GET /api/payment-method`; MCP
+     * adapters omit (the field is on the bootstrap customer snapshot).
+     */
+    getPaymentMethod?: () => Promise<PaymentMethodInfo>;
+    /**
+     * Optional: fetch the authenticated customer's usage snapshot for the
+     * active usage-based plan. When omitted, `useUsage()` falls back to
+     * reading the usage field out of `checkPurchase`.
+     */
+    getUsage?: () => Promise<GetUsageResult>;
+    createPayment: (params: {
+        planRef?: string;
+        productRef?: string;
+        customer?: PrefillCustomer;
+    }) => Promise<PaymentIntentResult>;
+    processPayment: (params: {
+        paymentIntentId: string;
+        productRef: string;
+        planRef?: string;
+    }) => Promise<ProcessPaymentResult>;
+    createTopupPayment: (params: {
+        amount: number;
+        currency?: string;
+    }) => Promise<TopupPaymentResult>;
+    cancelRenewal: (params: {
+        purchaseRef: string;
+        reason?: string;
+    }) => Promise<CancelResult>;
+    reactivateRenewal: (params: {
+        purchaseRef: string;
+    }) => Promise<ReactivateResult>;
+    activatePlan: (params: {
+        productRef: string;
+        planRef: string;
+    }) => Promise<ActivatePlanResult>;
+    createCheckoutSession: (params?: {
+        planRef?: string;
+        productRef?: string;
+        returnUrl?: string;
+    }) => Promise<TransportCheckoutSessionResult>;
+    createCustomerSession: () => Promise<TransportCustomerSessionResult>;
+}
+declare class UnsupportedTransportMethodError extends Error {
+    readonly method: string;
+    constructor(method: string);
+}
+
+interface PurchaseInfo {
+    reference: string;
+    productName: string;
+    productRef?: string;
+    status: string;
+    startDate: string;
+    endDate?: string;
+    cancelledAt?: string;
+    cancellationReason?: string;
+    /** Normalised amount in USD cents (for cross-currency aggregation). */
+    amount?: number;
+    /** Amount in minor units of `currency` — what the customer was actually charged. */
+    originalAmount?: number;
+    currency?: string;
+    /** Exchange rate used to convert `originalAmount` → `amount` (USD). */
+    exchangeRate?: number;
+    planType?: string;
+    isRecurring?: boolean;
+    nextBillingDate?: string;
+    billingCycle?: string;
+    planRef?: string;
+    planSnapshot?: {
+        reference?: string;
+        name?: string | null;
+        price?: number;
+        meterRef?: string;
+        limit?: number;
+        freeUnits?: number;
+        creditsPerUnit?: number;
+        planType?: string;
+        billingCycle?: string | null;
+        features?: Record<string, unknown> | null;
+    };
+    usage?: {
+        used: number;
+        overageUnits?: number;
+        overageCost?: number;
+        periodStart?: string;
+        periodEnd?: string;
+    };
+    /**
+     * Arbitrary metadata attached to the purchase. `metadata.purpose ===
+     * 'credit_topup'` signals a balance top-up rather than a plan purchase;
+     * see `isPlanPurchase` / `isTopupPurchase` for classification helpers.
+     */
+    metadata?: Record<string, unknown>;
+}
+interface CustomerPurchaseData {
+    customerRef?: string;
+    email?: string;
+    name?: string;
+    purchases: PurchaseInfo[];
+}
+interface PaymentIntentResult {
+    clientSecret: string;
+    publishableKey: string;
+    accountId?: string;
+    customerRef?: string;
+}
+/**
+ * Subset of merchant identity surfaced by `GET /v1/sdk/merchant`.
+ * Used by `<MandateText>` and customer-facing trust signals.
+ */
+interface Merchant {
+    displayName: string;
+    legalName: string;
+    supportEmail?: string;
+    supportUrl?: string;
+    termsUrl?: string;
+    privacyUrl?: string;
+    country?: string;
+    defaultCurrency?: string;
+    statementDescriptor?: string;
+    logoUrl?: string;
+}
+interface UseMerchantReturn {
+    merchant: Merchant | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface Product {
+    reference: string;
+    name?: string;
+    description?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+interface UseProductReturn {
+    product: Product | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface UsePlanOptions {
+    /** Plan reference (e.g. `'pln_premium'`). */
+    planRef?: string;
+    /**
+     * Optional product reference. When provided, the hook reuses the
+     * `usePlans` cache instead of fetching a dedicated plan endpoint.
+     */
+    productRef?: string;
+    /**
+     * Fetcher for plan lookup when `productRef` is not provided. Required in
+     * that mode so the hook stays dependency-free.
+     */
+    fetcher?: (productRef: string) => Promise<Plan[]>;
+}
+interface UsePlanReturn {
+    plan: Plan | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Optional customer fields forwarded to payment-intent creation so the
+ * backend customer record is authoritative. Read back via `useCustomer()`
+ * after the intent is created.
+ */
+interface PrefillCustomer {
+    name?: string;
+    email?: string;
+}
+interface TopupPaymentResult {
+    clientSecret: string;
+    publishableKey: string;
+    accountId?: string;
+    customerRef?: string;
+}
+interface UseTopupOptions {
+    amount: number;
+    currency?: string;
+}
+interface UseTopupReturn {
+    loading: boolean;
+    error: Error | null;
+    stripePromise: Promise<_stripe_stripe_js.Stripe | null> | null;
+    clientSecret: string | null;
+    startTopup: () => Promise<void>;
+    reset: () => void;
+}
+interface TopupFormProps {
+    amount: number;
+    currency?: string;
+    onSuccess?: (paymentIntent: PaymentIntent) => void;
+    onError?: (error: Error) => void;
+    returnUrl?: string;
+    submitButtonText?: string;
+    className?: string;
+    buttonClassName?: string;
+}
+interface PurchaseStatus {
+    loading: boolean;
+    /** True when data already exists but a background refetch is in progress */
+    isRefetching: boolean;
+    /** Last fetch error, or null if the most recent fetch succeeded */
+    error: Error | null;
+    customerRef?: string;
+    email?: string;
+    name?: string;
+    purchases: PurchaseInfo[];
+    hasProduct: (productName: string) => boolean;
+    /**
+     * Primary active purchase (paid or free) - most recent purchase with status === 'active'
+     * Backend keeps purchases as 'active' until expiration, even when cancelled.
+     * null if no active purchase exists
+     */
+    activePurchase: PurchaseInfo | null;
+    /**
+     * Check if user has any active paid purchase (amount > 0)
+     * Checks purchases with status === 'active'.
+     * Backend keeps purchases as 'active' until expiration, even when cancelled.
+     */
+    hasPaidPurchase: boolean;
+    /**
+     * Most recent active paid purchase (sorted by startDate)
+     * Returns purchase with status === 'active' and amount > 0.
+     * null if no active paid purchase exists
+     */
+    activePaidPurchase: PurchaseInfo | null;
+    /**
+     * Purchases that are not plans — e.g. credit top-ups, and any future
+     * balance-transaction purposes the backend introduces. Classified
+     * structurally (`planSnapshot == null`) with a belt-and-braces check on
+     * `metadata.purpose`. See `isPlanPurchase` / `isTopupPurchase`.
+     */
+    balanceTransactions: PurchaseInfo[];
+}
+/**
+ * SolvaPay Provider Configuration
+ * Sensible defaults for minimal code, but fully customizable
+ */
+interface BalanceStatus {
+    loading: boolean;
+    credits: number | null;
+    displayCurrency: string | null;
+    creditsPerMinorUnit: number | null;
+    displayExchangeRate: number | null;
+    refetch: () => Promise<void>;
+    adjustBalance: (credits: number) => void;
+}
+/**
+ * Hydration seed passed by MCP App hosts so `SolvaPayProvider` can mount
+ * with cached data instead of firing per-view tool calls. Non-MCP
+ * integrators leave this undefined — all current behaviour (fetch on
+ * mount, HTTP routes) is preserved.
+ */
+interface SolvaPayProviderInitial {
+    /** Authenticated customer ref (`customer.ref` from the bootstrap). */
+    customerRef: string | null;
+    purchase: PurchaseCheckResult | null;
+    paymentMethod: PaymentMethodInfo | null;
+    balance: CustomerBalanceResult | null;
+    usage: GetUsageResult | null;
+    merchant: Merchant;
+    product: Product;
+    plans: Plan[];
+}
+interface SolvaPayConfig {
+    /**
+     * API route configuration
+     * Defaults to standard Next.js API routes
+     */
+    api?: {
+        checkPurchase?: string;
+        createPayment?: string;
+        processPayment?: string;
+        createTopupPayment?: string;
+        customerBalance?: string;
+        cancelRenewal?: string;
+        reactivateRenewal?: string;
+        activatePlan?: string;
+        listPlans?: string;
+        getMerchant?: string;
+        getProduct?: string;
+        createCheckoutSession?: string;
+        createCustomerSession?: string;
+        getPaymentMethod?: string;
+        getUsage?: string;
+    };
+    /**
+     * Data-access transport. Replaces the default HTTP calls with any
+     * compatible implementation (e.g. `createMcpAppAdapter(app)` from
+     * `@solvapay/react/mcp`). When omitted, the provider builds a default
+     * HTTP transport from `config.api` + `config.fetch`.
+     */
+    transport?: SolvaPayTransport;
+    /**
+     * BCP-47 locale tag (e.g. 'en', 'sv-SE'). Threaded through every SDK
+     * component, `Intl.NumberFormat`, and Stripe Elements. Defaults to the
+     * runtime default (typically 'en').
+     */
+    locale?: string;
+    /**
+     * Partial copy overrides. Keys not supplied fall back to the bundled English
+     * defaults — consumers only provide the strings they actually want to change.
+     */
+    copy?: PartialSolvaPayCopy;
+    /**
+     * Authentication configuration
+     * Uses adapter pattern for flexible auth provider support
+     */
+    auth?: {
+        /**
+         * Auth adapter instance
+         * Default: checks localStorage for 'auth_token' key
+         *
+         * @example
+         * ```tsx
+         * import { createSupabaseAuthAdapter } from '@solvapay/react-supabase';
+         *
+         * <SolvaPayProvider
+         *   config={{
+         *     auth: {
+         *       adapter: createSupabaseAuthAdapter({
+         *         supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL!,
+         *         supabaseAnonKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+         *       })
+         *     }
+         *   }}
+         * >
+         * ```
+         */
+        adapter?: AuthAdapter;
+    };
+    /**
+     * Custom fetch implementation
+     * Default: uses global fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Request headers to include in all API calls
+     * Default: empty
+     */
+    headers?: HeadersInit | (() => Promise<HeadersInit>);
+    /**
+     * Custom error handler
+     * Default: logs to console
+     */
+    onError?: (error: Error, context: string) => void;
+    /**
+     * Pre-fetched seed for MCP App hosts. When provided, the provider
+     * mounts with the snapshot already applied — no `checkPurchase`,
+     * `getBalance`, `getMerchant`, `getProduct`, `getPlans`, or
+     * `getPaymentMethod` calls on first render. Non-MCP integrators leave
+     * this undefined; HTTP behaviour is unchanged.
+     */
+    initial?: SolvaPayProviderInitial;
+    /**
+     * Post-mutation re-fetch for MCP App hosts. When provided, the
+     * provider's `refreshBootstrap()` calls this to get a fresh
+     * `SolvaPayProviderInitial` snapshot (typically by re-invoking
+     * `manage_account` on the host) and re-applies it to provider state
+     * and the module caches. Non-MCP integrators leave this undefined —
+     * `refreshBootstrap()` falls back to `refetchPurchase()` +
+     * `balance.refetch()`. Return `null` to skip the refresh (e.g. when
+     * the host is offline).
+     */
+    refreshInitial?: () => Promise<SolvaPayProviderInitial | null>;
+}
+interface CancelResult {
+    reference?: string;
+    status?: string;
+    cancelledAt?: string;
+    [key: string]: unknown;
+}
+interface ReactivateResult {
+    reference?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+
+interface UsePaymentMethodReturn {
+    paymentMethod: PaymentMethodInfo | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface SolvaPayContextValue {
+    purchase: PurchaseStatus;
+    refetchPurchase: () => Promise<void>;
+    createPayment: (params: {
+        planRef?: string;
+        productRef?: string;
+        customer?: PrefillCustomer;
+    }) => Promise<PaymentIntentResult>;
+    processPayment?: (params: {
+        paymentIntentId: string;
+        productRef: string;
+        planRef?: string;
+    }) => Promise<ProcessPaymentResult>;
+    createTopupPayment: (params: {
+        amount: number;
+        currency?: string;
+    }) => Promise<TopupPaymentResult>;
+    cancelRenewal: (params: {
+        purchaseRef: string;
+        reason?: string;
+    }) => Promise<CancelResult>;
+    reactivateRenewal: (params: {
+        purchaseRef: string;
+    }) => Promise<ReactivateResult>;
+    activatePlan: (params: {
+        productRef: string;
+        planRef: string;
+    }) => Promise<ActivatePlanResult>;
+    customerRef?: string;
+    updateCustomerRef?: (newCustomerRef: string) => void;
+    balance: BalanceStatus;
+    /**
+     * Re-bootstrap the MCP snapshot (customer + product-scoped data).
+     * Always callable; on non-MCP transports falls back to
+     * `refetchPurchase()` + `balance.refetch()` so every caller can use
+     * the same post-mutation hook.
+     */
+    refreshBootstrap?: () => Promise<void>;
+    /** @internal Provider config — used by SDK hooks, not part of public API */
+    _config?: SolvaPayConfig;
+}
+interface SolvaPayProviderProps {
+    /**
+     * Configuration object with sensible defaults.
+     *
+     * To customise data access (e.g. route through MCP instead of HTTP), pass
+     * `config.transport`. Legacy per-method overrides (`createPayment`,
+     * `checkPurchase`, `processPayment`, `createTopupPayment`) have been
+     * removed in favour of the unified transport surface — see
+     * [`SolvaPayTransport`](../transport/types.ts) and
+     * `@solvapay/react/mcp` for an MCP implementation.
+     */
+    config?: SolvaPayConfig;
+    children: React.ReactNode;
+}
+/**
+ * Error type for payment operations
+ */
+interface PaymentError extends Error {
+    code?: string;
+    type?: string;
+}
+/**
+ * Plan returned by the SolvaPay API.
+ *
+ * All fields are optional except `reference` so the type stays compatible
+ * with partial JSON responses from custom fetcher functions.
+ */
+interface Plan {
+    type?: 'recurring' | 'one-time' | 'usage-based';
+    reference: string;
+    name?: string;
+    description?: string;
+    price?: number;
+    currency?: string;
+    currencySymbol?: string;
+    freeUnits?: number;
+    setupFee?: number;
+    trialDays?: number;
+    billingCycle?: string;
+    billingModel?: 'pre-paid' | 'post-paid';
+    creditsPerUnit?: number;
+    measures?: string;
+    limit?: number;
+    rolloverUnusedUnits?: boolean;
+    limits?: Record<string, unknown>;
+    features?: Record<string, unknown> | string[];
+    requiresPayment?: boolean;
+    default?: boolean;
+    isActive?: boolean;
+    maxActiveUsers?: number;
+    accessExpiryDays?: number;
+    status?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    interval?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for usePlans hook
+ */
+interface UsePlansOptions {
+    /**
+     * Fetcher function to retrieve plans
+     */
+    fetcher: (productRef: string) => Promise<Plan[]>;
+    /**
+     * Product reference to fetch plans for
+     */
+    productRef?: string;
+    /**
+     * Optional filter function to filter plans.
+     * Receives plan and its index (after sorting, if sortBy is provided).
+     */
+    filter?: (plan: Plan, index: number) => boolean;
+    /**
+     * Optional sort function to sort plans
+     */
+    sortBy?: (a: Plan, b: Plan) => number;
+    /**
+     * Auto-select first paid plan on load
+     */
+    autoSelectFirstPaid?: boolean;
+    /**
+     * Plan reference to select initially when plans load.
+     * Applied at most once when selectionReady is true.
+     * Takes priority over autoSelectFirstPaid.
+     */
+    initialPlanRef?: string;
+    /**
+     * When false, plans still fetch but auto-selection is deferred.
+     * When it transitions to true, one-shot initial selection fires.
+     * Defaults to true.
+     */
+    selectionReady?: boolean;
+}
+/**
+ * Return type for usePlans hook
+ */
+interface UsePlansReturn {
+    plans: Plan[];
+    loading: boolean;
+    error: Error | null;
+    selectedPlanIndex: number;
+    selectedPlan: Plan | null;
+    setSelectedPlanIndex: (index: number) => void;
+    selectPlan: (planRef: string) => void;
+    refetch: () => Promise<void>;
+    /** True after the one-shot initial selection has been applied */
+    isSelectionReady: boolean;
+}
+/**
+ * Return type for usePurchaseStatus hook
+ *
+ * Provides advanced purchase status helpers and utilities.
+ * Focuses on cancelled purchase logic and date formatting.
+ * For basic purchase data and paid status, use usePurchase() instead.
+ */
+interface PurchaseStatusReturn {
+    /**
+     * Most recent cancelled paid purchase (sorted by startDate)
+     * null if no cancelled paid purchase exists
+     */
+    cancelledPurchase: PurchaseInfo | null;
+    /**
+     * Whether to show cancelled purchase notice
+     * true if cancelledPurchase exists
+     */
+    shouldShowCancelledNotice: boolean;
+    /**
+     * Format a date string to locale format (e.g., "January 15, 2024")
+     * Returns null if dateString is not provided
+     */
+    formatDate: (dateString?: string) => string | null;
+    /**
+     * Calculate days until expiration date
+     * Returns null if endDate is not provided, otherwise returns days (0 or positive)
+     */
+    getDaysUntilExpiration: (endDate?: string) => number | null;
+}
+/**
+ * Payment form props - simplified and minimal
+ */
+/**
+ * Discriminated checkout-completion result surfaced by `<PaymentForm>` and
+ * `<CheckoutLayout>` via their `onResult` callback. Integrators handling
+ * both paid and free plans should use `onResult` to get a single typed
+ * callback; paid-only integrators keep using `onSuccess(paymentIntent)`.
+ */
+type PaymentResult = {
+    kind: 'paid';
+    paymentIntent: PaymentIntent;
+};
+type ActivationResult = {
+    kind: 'activated';
+    result: ActivatePlanResult;
+};
+type CheckoutResult = PaymentResult | ActivationResult;
+interface PaymentFormProps {
+    /**
+     * Plan reference to checkout. When omitted, the SDK auto-resolves the plan from
+     * productRef (requires exactly one active plan or a default plan). Pass explicitly
+     * when the product has multiple plans without a default.
+     */
+    planRef?: string;
+    /**
+     * Product reference. Required when planRef is omitted (for plan resolution)
+     * and for processing payment after confirmation.
+     */
+    productRef?: string;
+    /**
+     * Callback when payment succeeds. Fires on paid flows only — preserved
+     * exactly for backwards compatibility. Free/activation flows do NOT fire
+     * `onSuccess`; use `onResult` to receive both paid and activated results.
+     */
+    onSuccess?: (paymentIntent: PaymentIntent) => void;
+    /**
+     * Unified callback fired on both paid and activated completions with a
+     * discriminated result. Safe to provide alongside `onSuccess` — for paid
+     * flows both fire (in order: `onSuccess` first, then `onResult`).
+     */
+    onResult?: (result: CheckoutResult) => void;
+    /**
+     * Override the default free-plan activation step. When provided, the form
+     * awaits this promise on submit and fires `onResult` when it resolves.
+     * When omitted, the default behavior calls `activatePlan` from context.
+     */
+    onFreePlan?: (plan: Plan) => Promise<unknown> | void;
+    /**
+     * Callback when payment fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Return URL after payment completion. Defaults to current page URL if not provided.
+     */
+    returnUrl?: string;
+    /**
+     * Text for the submit button. Defaults to "Pay Now"
+     */
+    submitButtonText?: string;
+    /**
+     * Optional className for the form container
+     */
+    className?: string;
+    /**
+     * Optional className for the submit button
+     */
+    buttonClassName?: string;
+    /**
+     * Customer name/email to forward to backend PaymentIntent creation so the
+     * server-side customer record is authoritative. Echoed back via
+     * `useCustomer()` after the intent is created.
+     */
+    prefillCustomer?: PrefillCustomer;
+    /**
+     * When true, the default tree renders a terms/privacy checkbox and gates
+     * the submit button until it is ticked. No-op when custom `children` are
+     * passed — compose `<PaymentForm.TermsCheckbox />` yourself.
+     */
+    requireTermsAcceptance?: boolean;
+}
+interface UseTopupAmountSelectorOptions {
+    currency: string;
+    minAmount?: number;
+    maxAmount?: number;
+}
+interface UseTopupAmountSelectorReturn {
+    quickAmounts: number[];
+    selectedAmount: number | null;
+    customAmount: string;
+    resolvedAmount: number | null;
+    selectQuickAmount: (amount: number) => void;
+    setCustomAmount: (value: string) => void;
+    error: string | null;
+    validate: () => boolean;
+    reset: () => void;
+    currencySymbol: string;
+}
+type PurchaseStatusValue = 'pending' | 'active' | 'trialing' | 'past_due' | 'cancelled' | 'expired' | 'suspended' | 'refunded';
+
+export { type ActivationResult as A, type BalanceStatus as B, type CheckoutResult as C, type Merchant as D, type PaymentError as E, type PaymentIntentResult as F, type PaymentMethodInfo as G, type PaymentResult as H, type PurchaseStatusValue as I, type TopupPaymentResult as J, type TransportBalanceResult as K, type TransportCheckoutSessionResult as L, type MandateContext as M, type TransportCustomerSessionResult as N, UnsupportedTransportMethodError as O, type PaymentFormProps as P, type SolvaPayProviderInitial as Q, type ReactivateResult as R, type SolvaPayProviderProps as S, type TopupFormProps as T, type UsePlansOptions as U, type PrefillCustomer as a, type Plan as b, type PurchaseStatus as c, type SolvaPayContextValue as d, type UsePlansReturn as e, type UsePlanOptions as f, type UsePlanReturn as g, type UseProductReturn as h, type UseMerchantReturn as i, type SolvaPayCopy as j, type PurchaseStatusReturn as k, type CancelResult as l, type ActivatePlanResult as m, type UseTopupOptions as n, type UseTopupReturn as o, type UseTopupAmountSelectorOptions as p, type UseTopupAmountSelectorReturn as q, type UsePaymentMethodReturn as r, type SolvaPayTransport as s, type PaywallStructuredContent as t, type PartialSolvaPayCopy as u, type PurchaseInfo as v, type Product as w, type SolvaPayConfig as x, type CustomerPurchaseData as y, type MandateTemplate as z };