@solvapay/server 1.0.1-preview.2 → 1.0.1-preview.3

package/dist/edge.d.ts

@@ -77,12 +77,12 @@ interface components {
         VerifyEmailChange: {
             code: string;
         };
-        CreateCheckoutSessionRequest: {
+        CreateUiCheckoutSessionRequest: {
             /**
              * Customer reference
              * @example cus_3c4d5e6f7g8h
              */
-            customerReference: string;
+            customerRef: string;
             /**
              * Plan reference (optional)
              * @example pln_2b3c4d5e6f7g
@@ -188,6 +188,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;
@@ -1812,6 +1846,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 +1952,1214 @@ 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_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
@@ -2038,7 +3375,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']['CheckoutSessionResponse']>;
     createCustomerSession(params: components['schemas']['CreateCustomerSessionRequest']): Promise<components['schemas']['CreateCustomerSessionResponse']>;
 }
 
@@ -2084,7 +3421,7 @@ interface PaywallToolResult {
         mimeType?: string;
     }>;
     isError?: boolean;
-    structuredContent?: PaywallStructuredContent;
+    structuredContent?: PaywallStructuredContent | Record<string, unknown>;
 }
 
 /**
@@ -2126,6 +3463,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 +3543,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
      */
@@ -2273,7 +3620,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[];
 }
@@ -2285,7 +3632,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;
@@ -2294,6 +3641,16 @@ interface VirtualToolDefinition {
     }>;
 }
 
+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;
+}
+
 /**
  * Configuration for creating a SolvaPay instance.
  *
@@ -2411,7 +3768,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.
      *
@@ -2803,7 +4160,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
@@ -2813,6 +4170,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.
      *