@solvapay/server 1.0.2 → 1.0.4

package/dist/index.d.cts

@@ -1,19 +1,51 @@
-type WebhookEventType = 'payment.succeeded' | 'payment.failed' | 'payment.refunded' | 'payment.refund_failed' | 'purchase.created' | 'purchase.updated' | 'purchase.cancelled' | 'purchase.expired' | 'purchase.suspended' | 'customer.created' | 'customer.updated' | 'customer.deleted';
-interface WebhookEvent {
+type WebhookEventType = 'payment.succeeded' | 'payment.failed' | 'payment.refunded' | 'payment.refund_failed' | 'purchase.created' | 'purchase.updated' | 'purchase.cancelled' | 'purchase.expired' | 'purchase.suspended' | 'customer.created' | 'customer.updated' | 'customer.deleted' | 'checkout_session.created';
+interface WebhookProduct {
+    reference: string;
+}
+interface CustomerWebhookObject {
     id: string;
-    type: WebhookEventType;
+    created: number;
+    product: WebhookProduct | null;
+    reference?: string;
+    name?: string;
+    email?: string;
+    telephone?: string;
+    status?: string;
+}
+type WebhookPayloadObject = Record<string, unknown>;
+type WebhookEventObjectMap = {
+    'payment.succeeded': WebhookPayloadObject;
+    'payment.failed': WebhookPayloadObject;
+    'payment.refunded': WebhookPayloadObject;
+    'payment.refund_failed': WebhookPayloadObject;
+    'purchase.created': WebhookPayloadObject;
+    'purchase.updated': WebhookPayloadObject;
+    'purchase.cancelled': WebhookPayloadObject;
+    'purchase.expired': WebhookPayloadObject;
+    'purchase.suspended': WebhookPayloadObject;
+    'customer.created': CustomerWebhookObject;
+    'customer.updated': CustomerWebhookObject;
+    'customer.deleted': CustomerWebhookObject;
+    'checkout_session.created': WebhookPayloadObject;
+};
+type WebhookEventForType<TType extends WebhookEventType> = {
+    id: string;
+    type: TType;
     created: number;
     api_version: string;
     data: {
-        object: Record<string, any>;
-        previous_attributes: Record<string, any> | null;
+        object: WebhookEventObjectMap[TType];
+        previous_attributes: Record<string, unknown> | null;
     };
     livemode: boolean;
     request: {
         id: string | null;
         idempotency_key: string | null;
     };
-}
+};
+type WebhookEvent = {
+    [TType in WebhookEventType]: WebhookEventForType<TType>;
+}[WebhookEventType];
 
 interface components {
     schemas: {
@@ -77,12 +109,12 @@ interface components {
         VerifyEmailChange: {
             code: string;
         };
-        CreateCheckoutSessionRequest: {
+        CreateUiCheckoutSessionRequest: {
             /**
              * Customer reference
              * @example cus_3c4d5e6f7g8h
              */
-            customerReference: string;
+            customerRef: string;
             /**
              * Plan reference (optional)
              * @example pln_2b3c4d5e6f7g
@@ -94,7 +126,7 @@ interface components {
              */
             productRef: string;
         };
-        CheckoutSessionResponse: {
+        CreateUiCheckoutSessionResponse: {
             /**
              * Checkout session ID
              * @example 507f1f77bcf86cd799439011
@@ -188,6 +220,40 @@ interface components {
             /** @description Terms of Service acceptance */
             tosAcceptance?: components["schemas"]["TosAcceptance"];
         };
+        CreateCheckoutSessionRequest: {
+            /**
+             * Customer reference identifier
+             * @example cus_3c4d5e6f7g8h
+             */
+            customerRef: string;
+            /**
+             * Product reference identifier
+             * @example prd_1A2B3C4D
+             */
+            productRef: string;
+            /**
+             * Plan reference identifier (optional)
+             * @example pln_2b3c4d5e6f7g
+             */
+            planRef?: string;
+            /**
+             * URL to redirect to after successful payment (optional)
+             * @example https://example.com/payment-success
+             */
+            returnUrl?: 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;
+        };
         Signup: {
             name: string;
             email: string;
@@ -1036,6 +1102,40 @@ interface components {
                 description?: string;
             }[];
         };
+        McpToolPlanMapping: {
+            /**
+             * Tool name
+             * @example deep_research
+             */
+            name: string;
+            /**
+             * Plan keys this tool should be gated to
+             * @example [
+             *       "pro"
+             *     ]
+             */
+            planKeys: string[];
+        };
+        ConfigureMcpPlansRequest: {
+            /** @description Required free plan configuration for updates. Applies to the existing default free plan only. */
+            freePlan: components["schemas"]["McpBootstrapFreePlanConfig"];
+            /** @description Optional paid plan definitions. [] reverts to free-only, omitted leaves existing paid plans unchanged. */
+            paidPlans?: components["schemas"]["McpBootstrapPaidPlanInput"][];
+            /** @description Optional tool-to-plan remapping. If paidPlans is omitted, only this remapping is applied. */
+            toolMapping?: components["schemas"]["McpToolPlanMapping"][];
+        };
+        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;
+            };
+        };
         McpBootstrapPreviewResult: {
             /** @description Discovered tools from the origin MCP server */
             discoveredTools: {
@@ -1812,6 +1912,101 @@ interface components {
                 [key: string]: string;
             };
         };
+        RevenueDataDto: {
+            grossRevenue: number;
+            refunds: number;
+            platformFees: number;
+            netRevenue: number;
+            costOfRevenue: number;
+            grossProfit?: Record<string, never> | null;
+            grossMargin?: Record<string, never> | null;
+            recognisedRevenue: number;
+            deferredRevenue: number;
+            hasCostTransactions: boolean;
+        };
+        BalanceDataDto: {
+            openingBalance: number;
+            paymentsReceived: number;
+            refundsIssued: number;
+            platformFees: number;
+            costsPaid: number;
+            closingBalance: number;
+            netChange: number;
+        };
+        MonthlyFinancialsDto: {
+            month: string;
+            revenue: components["schemas"]["RevenueDataDto"];
+            balance: components["schemas"]["BalanceDataDto"];
+        };
+        RevenueResponseDto: {
+            current: components["schemas"]["RevenueDataDto"];
+            prior: components["schemas"]["RevenueDataDto"];
+            monthly: components["schemas"]["MonthlyFinancialsDto"][];
+            periodLabel: string;
+            /**
+             * ISO 4217 currency code
+             * @example SEK
+             */
+            currency: string;
+        };
+        BalanceResponseDto: {
+            current: components["schemas"]["BalanceDataDto"];
+            monthly: components["schemas"]["MonthlyFinancialsDto"][];
+            periodLabel: string;
+            /**
+             * ISO 4217 currency code
+             * @example SEK
+             */
+            currency: string;
+        };
+        ProductRevenueRowDto: {
+            productRef: string;
+            productName: string;
+            productType: string;
+            revenue: number;
+            costs: number;
+            grossProfit?: Record<string, never> | null;
+            share: number;
+            estimatedARR: number;
+            transactionCount: number;
+        };
+        TopProductDto: {
+            name: string;
+            revenue: number;
+        };
+        RevenueByProductResponseDto: {
+            products: components["schemas"]["ProductRevenueRowDto"][];
+            activeProductCount: number;
+            totalMRR: number;
+            topProduct?: components["schemas"]["TopProductDto"] | null;
+            /**
+             * ISO 4217 currency code
+             * @example SEK
+             */
+            currency: string;
+        };
+        LedgerEntryDto: {
+            date: string;
+            reference: string;
+            description: string;
+            type: string;
+            direction: string;
+            account: string;
+            debit: number;
+            credit: number;
+            status: string;
+        };
+        LedgerResponseDto: {
+            entries: components["schemas"]["LedgerEntryDto"][];
+            total: number;
+            totalCredit: number;
+            totalDebit: number;
+            /**
+             * ISO 4217 currency code
+             * @example SEK
+             */
+            currency: string;
+        };
         /** @description Auto-generated fallback schema for unresolved reference: McpBootstrapPreviewValidationError */
         McpBootstrapPreviewValidationError: {
             [key: string]: unknown;
@@ -1823,6 +2018,1255 @@ interface components {
     headers: never;
     pathItems: never;
 }
+interface operations {
+    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": {
+                    /**
+                     * Plan reference to purchase
+                     * @example pln_2b3c4d5e6f7g
+                     */
+                    planRef: string;
+                    /**
+                     * Product reference that owns the plan
+                     * @example prd_1A2B3C4D
+                     */
+                    productRef: string;
+                    /**
+                     * Customer reference identifier
+                     * @example cus_3c4d5e6f7g8h
+                     */
+                    customerReference: string;
+                    /**
+                     * Name of the pricing tier to purchase (for plans with pricingTiers). If not specified, uses the plan base price.
+                     * @example Pro
+                     */
+                    pricingTier?: string;
+                };
+            };
+        };
+        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 MongoDB ID */
+                id: 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 Stripe payment intent ID (format: pi_xxx) */
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** @description Payment processing data */
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * Product reference that owns the plan
+                     * @example prd_123
+                     */
+                    productRef: string;
+                    /**
+                     * Customer reference identifier
+                     * @example cus_456
+                     */
+                    customerRef: string;
+                    /**
+                     * Plan reference - helps determine if payment is for purchase
+                     * @example pln_789
+                     */
+                    planRef?: string;
+                };
+            };
+        };
+        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 Stripe 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"]["McpBootstrapRequest"];
+            };
+        };
+        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"]["ConfigureMcpPlansRequest"];
+            };
+        };
+        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?: never;
+        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": {
+                    /**
+                     * Customer identifier
+                     * @example cus_3C4D5E6F
+                     */
+                    customerId: string;
+                    /**
+                     * Action type (default: api_call)
+                     * @example api_call
+                     * @enum {string}
+                     */
+                    actionType?: "transaction" | "api_call" | "hour" | "email" | "storage" | "custom";
+                    /**
+                     * Number of usage units (default: 1)
+                     * @example 1
+                     */
+                    units?: number;
+                    /** @description Product reference */
+                    productReference?: string;
+                    /** @description Purchase reference */
+                    purchaseReference?: string;
+                    /**
+                     * Outcome (default: success)
+                     * @enum {string}
+                     */
+                    outcome?: "success" | "paywall" | "fail";
+                    /** @description Arbitrary event properties */
+                    metadata?: {
+                        [key: string]: unknown;
+                    };
+                    /**
+                     * Format: date-time
+                     * @description ISO 8601 timestamp (defaults to now)
+                     */
+                    timestamp?: string;
+                    /** @description Unique key to prevent duplicate recording (max 256 chars) */
+                    idempotencyKey?: string;
+                };
+            };
+        };
+        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": {
+                    events: {
+                        customerId: string;
+                        /** @enum {string} */
+                        actionType?: "transaction" | "api_call" | "hour" | "email" | "storage" | "custom";
+                        units?: number;
+                        productReference?: string;
+                        purchaseReference?: string;
+                        /** @enum {string} */
+                        outcome?: "success" | "paywall" | "fail";
+                        metadata?: {
+                            [key: string]: unknown;
+                        };
+                        /** Format: date-time */
+                        timestamp?: string;
+                        idempotencyKey?: string;
+                    }[];
+                };
+            };
+        };
+        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"]["RecordMeterEventDto"];
+            };
+        };
+        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"]["RecordBulkMeterEventsDto"];
+            };
+        };
+        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;
+            };
+        };
+    };
+    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_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;
+            };
+        };
+    };
+    PurchaseSdkController_listPurchases: {
+        parameters: {
+            query?: {
+                /** @description Filter by purchase status */
+                status?: "pending" | "active" | "trialing" | "past_due" | "cancelled" | "expired" | "suspended" | "refunded";
+                /** @description Filter by product ID */
+                productId?: string;
+                /** @description Filter by customer ID */
+                customerId?: 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"]["PurchaseResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    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"]["PurchaseResponse"][];
+                    };
+                };
+            };
+            /** @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"]["PurchaseResponse"][];
+                    };
+                };
+            };
+            /** @description Product not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    PurchaseSdkController_getPurchase: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Purchase ID or reference */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Purchase retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PurchaseResponse"];
+                };
+            };
+            /** @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"]["PurchaseResponse"];
+                    };
+                };
+            };
+            /** @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;
+            };
+        };
+    };
+}
 
 /**
  * SolvaPay API Client Type Definitions
@@ -1904,6 +3348,10 @@ interface ToolPlanMappingInput {
     planRefs?: string[];
     planKeys?: string[];
 }
+interface McpToolPlanMappingInput {
+    name: string;
+    planKeys: string[];
+}
 interface McpBootstrapRequest {
     name?: string;
     description?: string;
@@ -1940,6 +3388,26 @@ interface McpBootstrapResponse {
         description?: string;
     }>;
 }
+interface ConfigureMcpPlansRequest {
+    paidPlans?: McpBootstrapPaidPlanInput[];
+    toolMapping?: McpToolPlanMappingInput[];
+}
+interface ConfigureMcpPlansResponse {
+    product: components['schemas']['SdkProductResponse'];
+    mcpServer: {
+        id?: string;
+        reference?: string;
+        subdomain?: string;
+        mcpProxyUrl?: string;
+        url: string;
+        defaultPlanId?: string;
+    };
+    planMap: Record<string, {
+        id: string;
+        reference: string;
+        name?: string;
+    }>;
+}
 /**
  * SolvaPay API Client Interface
  *
@@ -1981,6 +3449,7 @@ interface SolvaPayClient {
         name: string;
     }>;
     bootstrapMcpProduct?(params: McpBootstrapRequest): Promise<McpBootstrapResponse>;
+    configureMcpPlans?(productRef: string, params: ConfigureMcpPlansRequest): Promise<ConfigureMcpPlansResponse>;
     updateProduct?(productRef: string, params: components['schemas']['UpdateProductRequest']): Promise<components['schemas']['SdkProductResponse']>;
     deleteProduct?(productRef: string): Promise<void>;
     cloneProduct?(productRef: string, overrides?: {
@@ -2038,7 +3507,7 @@ interface SolvaPayClient {
         customerRef: string;
         productRef: string;
     }): Promise<components['schemas']['UserInfoResponse']>;
-    createCheckoutSession(params: components['schemas']['CreateCheckoutSessionRequest']): Promise<components['schemas']['CheckoutSessionResponse']>;
+    createCheckoutSession(params: operations['CheckoutSessionSdkController_createCheckoutSession']['requestBody']['content']['application/json']): Promise<components['schemas']['CreateCheckoutSessionResponse']>;
     createCustomerSession(params: components['schemas']['CreateCustomerSessionRequest']): Promise<components['schemas']['CreateCustomerSessionResponse']>;
 }
 
@@ -2084,7 +3553,7 @@ interface PaywallToolResult {
         mimeType?: string;
     }>;
     isError?: boolean;
-    structuredContent?: PaywallStructuredContent;
+    structuredContent?: PaywallStructuredContent | Record<string, unknown>;
 }
 
 /**
@@ -2126,6 +3595,16 @@ interface RetryOptions {
      */
     onRetry?: (error: Error, attempt: number) => void;
 }
+interface McpToolExtra {
+    authInfo?: {
+        token: string;
+        clientId: string;
+        scopes: string[];
+        expiresAt?: number;
+        extra?: Record<string, unknown>;
+    };
+    [key: string]: unknown;
+}
 /**
  * Options for configuring payable protection
  */
@@ -2196,7 +3675,7 @@ interface McpAdapterOptions {
     /**
      * Extract customer reference from MCP args
      */
-    getCustomerRef?: (args: any) => string | Promise<string>;
+    getCustomerRef?: (args: any, extra?: McpToolExtra) => string | Promise<string>;
     /**
      * Transform the response before wrapping in MCP format
      */
@@ -2215,7 +3694,7 @@ interface VirtualToolsOptions {
     /** Product reference (required) */
     product: string;
     /** Extract customer reference from MCP tool args */
-    getCustomerRef: (args: Record<string, unknown>) => string;
+    getCustomerRef: (args: Record<string, unknown>, extra?: McpToolExtra) => string;
     /** Tool names to exclude from registration (optional) */
     exclude?: string[];
 }
@@ -2227,7 +3706,7 @@ interface VirtualToolDefinition {
         properties: Record<string, object>;
         required: string[];
     };
-    handler: (args: Record<string, unknown>) => Promise<{
+    handler: (args: Record<string, unknown>, extra?: McpToolExtra) => Promise<{
         content: Array<{
             type: string;
             text: string;
@@ -2246,6 +3725,25 @@ declare const VIRTUAL_TOOL_DEFINITIONS: {
 }[];
 declare function createVirtualTools(apiClient: SolvaPayClient, options: VirtualToolsOptions): VirtualToolDefinition[];
 
+type ZodRawShape = Record<string, unknown>;
+type JsonSchemaProperty = {
+    type?: string;
+    enum?: unknown[];
+    items?: JsonSchemaProperty;
+    properties?: Record<string, JsonSchemaProperty>;
+};
+interface McpServerLike {
+    registerTool: (name: string, config: Record<string, unknown>, handler: (args: Record<string, unknown>, extra?: McpToolExtra) => unknown) => unknown;
+}
+interface RegisterVirtualToolsMcpOptions extends Omit<VirtualToolsOptions, 'getCustomerRef'> {
+    getCustomerRef?: VirtualToolsOptions['getCustomerRef'];
+    filter?: (definition: VirtualToolDefinition) => boolean;
+    mapDefinition?: (definition: VirtualToolDefinition) => VirtualToolDefinition;
+    wrapHandler?: (handler: VirtualToolDefinition['handler'], definition: VirtualToolDefinition) => (args: Record<string, unknown>, extra?: McpToolExtra) => Promise<unknown> | unknown;
+}
+declare function jsonSchemaToZodRawShape(properties: Record<string, JsonSchemaProperty>, required?: string[]): ZodRawShape;
+declare function registerVirtualToolsMcpImpl(server: McpServerLike, apiClient: SolvaPayClient, options: RegisterVirtualToolsMcpOptions): void;
+
 /**
  * Configuration for creating a SolvaPay instance.
  *
@@ -2363,7 +3861,7 @@ interface PayableFunction {
      * });
      * ```
      */
-    mcp<T = any>(businessLogic: (args: any) => Promise<T>, options?: McpAdapterOptions): (args: Record<string, unknown>) => Promise<unknown>;
+    mcp<T = any>(businessLogic: (args: any) => Promise<T>, options?: McpAdapterOptions): (args: Record<string, unknown>, extra?: McpToolExtra) => Promise<unknown>;
     /**
      * Pure function adapter for direct function protection.
      *
@@ -2736,6 +4234,13 @@ interface SolvaPay {
      * fast setup flows where you want one call for product + plans + MCP config.
      */
     bootstrapMcpProduct(params: McpBootstrapRequest): Promise<McpBootstrapResponse>;
+    /**
+     * Configure MCP plans and tool mappings for an existing MCP product.
+     *
+     * This helper wraps the backend MCP plans endpoint and supports adding/removing
+     * paid plans as well as remapping tool access.
+     */
+    configureMcpPlans(productRef: string, params: ConfigureMcpPlansRequest): Promise<ConfigureMcpPlansResponse>;
     /**
      * Get virtual tool definitions with bound handlers for MCP server integration.
      *
@@ -2755,7 +4260,7 @@ interface SolvaPay {
      * ```typescript
      * const virtualTools = solvaPay.getVirtualTools({
      *   product: 'prd_myapi',
-     *   getCustomerRef: args => args._auth?.customer_ref || 'anonymous',
+     *   getCustomerRef: (_args, extra) => String(extra?.authInfo?.extra?.customer_ref || 'anonymous'),
      * });
      *
      * // Register on your MCP server
@@ -2765,6 +4270,13 @@ interface SolvaPay {
      * ```
      */
     getVirtualTools(options: VirtualToolsOptions): VirtualToolDefinition[];
+    /**
+     * Register virtual tools directly on an MCP server with one call.
+     *
+     * This helper converts virtual tool JSON schemas to Zod schemas and registers
+     * each tool on an MCP server that supports `registerTool()`.
+     */
+    registerVirtualToolsMcp(server: McpServerLike, options: RegisterVirtualToolsMcpOptions): Promise<void>;
     /**
      * Direct access to the API client for advanced operations.
      *
@@ -2937,6 +4449,76 @@ declare class PaywallError extends Error {
     constructor(message: string, structuredContent: PaywallStructuredContent);
 }
 
+/**
+ * MCP OAuth helper utilities.
+ *
+ * These helpers are intentionally lightweight and do not verify JWT signatures.
+ * Use them after token validation (for example via /v1/customer/auth/userinfo).
+ */
+declare class McpBearerAuthError extends Error {
+    constructor(message: string);
+}
+type McpBearerCustomerRefOptions = {
+    claimPriority?: string[];
+};
+declare function extractBearerToken(authorization?: string | null): string | null;
+declare function decodeJwtPayload(token: string): Record<string, unknown>;
+declare function getCustomerRefFromJwtPayload(payload: Record<string, unknown>, options?: McpBearerCustomerRefOptions): string;
+declare function getCustomerRefFromBearerAuthHeader(authorization?: string | null, options?: McpBearerCustomerRefOptions): string;
+
+interface BuildAuthInfoFromBearerOptions extends McpBearerCustomerRefOptions {
+    clientId?: string;
+    defaultScopes?: string[];
+    includePayload?: boolean;
+}
+declare function buildAuthInfoFromBearer(authorization?: string | null, options?: BuildAuthInfoFromBearerOptions): McpToolExtra['authInfo'] | null;
+
+type RequestLike = {
+    method?: string;
+    path?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    auth?: unknown;
+};
+type ResponseLike = {
+    status: (code: number) => ResponseLike;
+    json: (payload: unknown) => void;
+    setHeader: (name: string, value: string) => void;
+};
+type NextLike = () => void;
+type Middleware = (req: RequestLike, res: ResponseLike, next: NextLike) => void;
+interface OAuthAuthorizationServerOptions {
+    apiBaseUrl: string;
+    productRef: string;
+}
+interface McpOAuthBridgeOptions {
+    publicBaseUrl: string;
+    apiBaseUrl: string;
+    productRef: string;
+    mcpPath?: string;
+    requireAuth?: boolean;
+    authInfo?: BuildAuthInfoFromBearerOptions;
+    protectedResourcePath?: string;
+    authorizationServerPath?: string;
+}
+declare function getOAuthProtectedResourceResponse(publicBaseUrl: string): {
+    resource: string;
+    authorization_servers: string[];
+    scopes_supported: string[];
+};
+declare function getOAuthAuthorizationServerResponse({ apiBaseUrl, productRef, }: OAuthAuthorizationServerOptions): {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint: string;
+    token_endpoint_auth_methods_supported: string[];
+    response_types_supported: string[];
+    grant_types_supported: string[];
+    scopes_supported: string[];
+    code_challenge_methods_supported: string[];
+};
+declare function createMcpOAuthBridge(options: McpOAuthBridgeOptions): Middleware[];
+
 /**
  * Utility functions for the SolvaPay Server SDK
  */
@@ -2980,23 +4562,6 @@ declare class PaywallError extends Error {
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 
-/**
- * MCP OAuth helper utilities.
- *
- * These helpers are intentionally lightweight and do not verify JWT signatures.
- * Use them after token validation (for example via /v1/customer/auth/userinfo).
- */
-declare class McpBearerAuthError extends Error {
-    constructor(message: string);
-}
-type McpBearerCustomerRefOptions = {
-    claimPriority?: string[];
-};
-declare function extractBearerToken(authorization?: string | null): string | null;
-declare function decodeJwtPayload(token: string): Record<string, unknown>;
-declare function getCustomerRefFromJwtPayload(payload: Record<string, unknown>, options?: McpBearerCustomerRefOptions): string;
-declare function getCustomerRefFromBearerAuthHeader(authorization?: string | null, options?: McpBearerCustomerRefOptions): string;
-
 /**
  * Helper Types
  *
@@ -3367,4 +4932,4 @@ declare function verifyWebhook({ body, signature, secret, }: {
     secret: string;
 }): WebhookEvent;
 
-export { type AuthenticatedUser, type CreateSolvaPayConfig, type CustomerResponseMapped, type ErrorResult, type HttpAdapterOptions, type McpAdapterOptions, McpBearerAuthError, type McpBootstrapFreePlanConfig, type McpBootstrapPaidPlanInput, type McpBootstrapRequest, type McpBootstrapResponse, type NextAdapterOptions, type OneTimePurchaseInfo, type PayableFunction, type PayableOptions, type PaywallArgs, PaywallError, type PaywallMetadata, type PaywallStructuredContent, type PaywallToolResult, type ProcessPaymentResult, type RetryOptions, type ServerClientOptions, type SolvaPay, type SolvaPayClient, type ToolPlanMappingInput, VIRTUAL_TOOL_DEFINITIONS, type VirtualToolDefinition, type VirtualToolsOptions, type WebhookEvent, type WebhookEventType, cancelPurchaseCore, createCheckoutSessionCore, createCustomerSessionCore, createPaymentIntentCore, createSolvaPay, createSolvaPayClient, createVirtualTools, decodeJwtPayload, extractBearerToken, getAuthenticatedUserCore, getCustomerRefFromBearerAuthHeader, getCustomerRefFromJwtPayload, handleRouteError, isErrorResult, listPlansCore, processPaymentIntentCore, syncCustomerCore, verifyWebhook, withRetry };
+export { type AuthenticatedUser, type ConfigureMcpPlansRequest, type ConfigureMcpPlansResponse, type CreateSolvaPayConfig, type CustomerResponseMapped, type CustomerWebhookObject, type ErrorResult, type HttpAdapterOptions, type McpAdapterOptions, McpBearerAuthError, type McpBootstrapFreePlanConfig, type McpBootstrapPaidPlanInput, type McpBootstrapRequest, type McpBootstrapResponse, type McpServerLike, type McpToolExtra, type McpToolPlanMappingInput, type NextAdapterOptions, type OneTimePurchaseInfo, type PayableFunction, type PayableOptions, type PaywallArgs, PaywallError, type PaywallMetadata, type PaywallStructuredContent, type PaywallToolResult, type ProcessPaymentResult, type RegisterVirtualToolsMcpOptions, type RetryOptions, type ServerClientOptions, type SolvaPay, type SolvaPayClient, type ToolPlanMappingInput, VIRTUAL_TOOL_DEFINITIONS, type VirtualToolDefinition, type VirtualToolsOptions, type WebhookEvent, type WebhookEventForType, type WebhookEventObjectMap, type WebhookEventType, type WebhookProduct, buildAuthInfoFromBearer, cancelPurchaseCore, createCheckoutSessionCore, createCustomerSessionCore, createMcpOAuthBridge, createPaymentIntentCore, createSolvaPay, createSolvaPayClient, createVirtualTools, decodeJwtPayload, extractBearerToken, getAuthenticatedUserCore, getCustomerRefFromBearerAuthHeader, getCustomerRefFromJwtPayload, getOAuthAuthorizationServerResponse, getOAuthProtectedResourceResponse, handleRouteError, isErrorResult, jsonSchemaToZodRawShape, listPlansCore, processPaymentIntentCore, registerVirtualToolsMcpImpl, syncCustomerCore, verifyWebhook, withRetry };