@paid-ai/paid-node 0.4.1 → 0.5.0-alpha2

package/dist/cjs/integrations/utils/base-handler.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Framework-agnostic base handler for Paid SDK integrations
+ * Provides consistent request handling, validation, and error handling
+ */
+import type { PaidClient } from "../../Client.js";
+import { type PaidClientConfig } from "../client.js";
+export interface BaseRequestContext<TBody = any, TParams = Record<string, string>> {
+    body: TBody;
+    headers: Record<string, string>;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    params?: TParams;
+    query?: Record<string, string>;
+}
+export interface BaseResponseContext {
+    json: (data: any, status?: number) => any;
+    error: (message: string, status: number) => any;
+}
+export interface BaseHandlerConfig extends PaidClientConfig {
+    validate?: (body: any) => Promise<void> | void;
+    transformRequest?: (body: any) => any;
+    transformResponse?: (data: any) => any;
+}
+export type HandlerFunction<TRequest, TResponse> = (client: PaidClient, request: TRequest, params?: Record<string, string>, organizationId?: string) => Promise<{
+    success: boolean;
+    data?: TResponse;
+    error?: string;
+    status?: number;
+}>;
+/**
+ * Creates a framework-agnostic handler with automatic client initialization,
+ * validation, and error handling
+ *
+ * @param handler - Business logic handler function
+ * @param options - Handler configuration options
+ * @returns Framework-agnostic handler function
+ *
+ * @example
+ * ```typescript
+ * const customersHandler = createHandler(
+ *   async (client, body) => {
+ *     const customer = await createCustomerWithDefaults(client, body);
+ *     return { success: true, data: customer };
+ *   },
+ *   { requiredFields: ['externalId'] }
+ * );
+ * ```
+ */
+export declare function createHandler<TRequest = any, TResponse = any>(handler: HandlerFunction<TRequest, TResponse>, options?: {
+    requiredFields?: (keyof TRequest)[];
+    allowedMethods?: Array<"GET" | "POST" | "PUT" | "DELETE" | "PATCH">;
+    requireOrganizationId?: boolean;
+}): (request: BaseRequestContext<TRequest>, response: BaseResponseContext, config?: BaseHandlerConfig) => Promise<any>;
+/**
+ * Helper to create a fetch-based handler for simple API calls
+ *
+ * @param endpoint - Function that generates the endpoint URL from org ID and request body
+ * @param options - Optional method, request/response transformations
+ * @returns Handler function that makes the API call
+ *
+ * @example
+ * ```typescript
+ * const activateHandler = createHandler(
+ *   createFetchHandler(
+ *     (orgId, req) => `/api/organizations/${orgId}/orders/${req.orderId}/activate-sync`,
+ *     {
+ *       method: "POST",
+ *       transformRequest: (req) => ({ confirmationToken: req.confirmationToken }),
+ *       transformResponse: (data) => ({ order: data.order, billing: data.billing })
+ *     }
+ *   ),
+ *   { requireOrganizationId: true }
+ * );
+ * ```
+ */
+export declare function createFetchHandler<TRequest, TResponse>(endpoint: (orgId: string, body: TRequest, params?: Record<string, string>) => string, options?: {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    transformRequest?: (body: TRequest) => any;
+    transformResponse?: (data: any) => TResponse;
+}): HandlerFunction<TRequest, TResponse>;

package/dist/cjs/integrations/utils/base-handler.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Framework-agnostic base handler for Paid SDK integrations
+ * Provides consistent request handling, validation, and error handling
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHandler = createHandler;
+exports.createFetchHandler = createFetchHandler;
+const client_js_1 = require("../client.js");
+/**
+ * Creates a framework-agnostic handler with automatic client initialization,
+ * validation, and error handling
+ *
+ * @param handler - Business logic handler function
+ * @param options - Handler configuration options
+ * @returns Framework-agnostic handler function
+ *
+ * @example
+ * ```typescript
+ * const customersHandler = createHandler(
+ *   async (client, body) => {
+ *     const customer = await createCustomerWithDefaults(client, body);
+ *     return { success: true, data: customer };
+ *   },
+ *   { requiredFields: ['externalId'] }
+ * );
+ * ```
+ */
+function createHandler(handler, options = {}) {
+    const { requiredFields = [], allowedMethods = ["POST"], requireOrganizationId = false } = options;
+    return function (request_1, response_1) {
+        return __awaiter(this, arguments, void 0, function* (request, response, config = {}) {
+            if (!allowedMethods.includes(request.method)) {
+                return response.error("Method not allowed", 405);
+            }
+            for (const field of requiredFields) {
+                if (!request.body[field]) {
+                    return response.error(`${String(field)} is required`, 400);
+                }
+            }
+            if (config.validate) {
+                try {
+                    yield config.validate(request.body);
+                }
+                catch (error) {
+                    return response.error(error instanceof Error ? error.message : "Validation failed", 400);
+                }
+            }
+            try {
+                const client = (0, client_js_1.initializePaidClient)(config);
+                let organizationId;
+                if (requireOrganizationId) {
+                    const orgId = yield (0, client_js_1.getOrganizationId)(config);
+                    if (!orgId) {
+                        return response.error("Organization not found", 500);
+                    }
+                    organizationId = orgId;
+                }
+                const requestData = config.transformRequest
+                    ? config.transformRequest(request.body)
+                    : request.body;
+                const result = yield handler(client, requestData, request.params, organizationId);
+                if (!result.success) {
+                    return response.error(result.error || "Operation failed", result.status || 500);
+                }
+                const responseData = config.transformResponse
+                    ? config.transformResponse(result.data)
+                    : { data: result.data };
+                return response.json(responseData, 200);
+            }
+            catch (error) {
+                console.error("Handler error:", error);
+                if (error instanceof TypeError && error.message.includes("fetch")) {
+                    return response.error("Network error: Unable to reach Paid API", 503);
+                }
+                return response.error(error instanceof Error ? error.message : "Internal server error", 500);
+            }
+        });
+    };
+}
+/**
+ * Helper to create a fetch-based handler for simple API calls
+ *
+ * @param endpoint - Function that generates the endpoint URL from org ID and request body
+ * @param options - Optional method, request/response transformations
+ * @returns Handler function that makes the API call
+ *
+ * @example
+ * ```typescript
+ * const activateHandler = createHandler(
+ *   createFetchHandler(
+ *     (orgId, req) => `/api/organizations/${orgId}/orders/${req.orderId}/activate-sync`,
+ *     {
+ *       method: "POST",
+ *       transformRequest: (req) => ({ confirmationToken: req.confirmationToken }),
+ *       transformResponse: (data) => ({ order: data.order, billing: data.billing })
+ *     }
+ *   ),
+ *   { requireOrganizationId: true }
+ * );
+ * ```
+ */
+function createFetchHandler(endpoint, options) {
+    return (client, requestBody, params, organizationId) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!organizationId) {
+            return {
+                success: false,
+                error: "Organization ID is required for this operation",
+                status: 500,
+            };
+        }
+        try {
+            const url = endpoint(organizationId, requestBody, params);
+            const body = (options === null || options === void 0 ? void 0 : options.transformRequest)
+                ? options.transformRequest(requestBody)
+                : requestBody;
+            const baseUrl = ((_a = client._options) === null || _a === void 0 ? void 0 : _a.baseUrl) || "https://api.agentpaid.io/api/v1";
+            const apiKey = (_b = client._options) === null || _b === void 0 ? void 0 : _b.token;
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: "API key not found in client",
+                    status: 500,
+                };
+            }
+            const fetchResponse = yield fetch(`${baseUrl}${url}`, {
+                method: (options === null || options === void 0 ? void 0 : options.method) || "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: (options === null || options === void 0 ? void 0 : options.method) !== "GET" ? JSON.stringify(body) : undefined,
+            });
+            if (!fetchResponse.ok) {
+                const errorText = yield fetchResponse.text();
+                console.error("API error:", errorText);
+                return {
+                    success: false,
+                    error: `API request failed: ${errorText}`,
+                    status: fetchResponse.status,
+                };
+            }
+            const data = yield fetchResponse.json();
+            const transformedData = (options === null || options === void 0 ? void 0 : options.transformResponse)
+                ? options.transformResponse(data)
+                : data;
+            return { success: true, data: transformedData };
+        }
+        catch (error) {
+            console.error("Fetch error:", error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+                status: 500,
+            };
+        }
+    });
+}

package/dist/cjs/integrations/utils/create-adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Generic adapter factory - eliminates repetitive adapter code
+ * Works with any framework (Express, Fastify, Hono, Next.js, etc.)
+ */
+/**
+ * Creates a framework adapter for any HTTP framework
+ * Automatically extracts headers and converts request/response
+ *
+ * @param extractors - Framework-specific extraction functions
+ * @returns Adapter function that wraps core handlers
+ *
+ * @example
+ * ```typescript
+ * const nextjsAdapter = createFrameworkAdapter({
+ *   getBody: async (req) => await req.json(),
+ *   getHeaders: (req) => Object.fromEntries(req.headers),
+ *   getMethod: (req) => req.method || "GET",
+ *   sendJson: (data, status) => NextResponse.json(data, { status })
+ * });
+ * ```
+ */
+export declare function createFrameworkAdapter<TFrameworkReq = any, TFrameworkRes = any>(extractors: {
+    getBody: (req: TFrameworkReq) => any | Promise<any>;
+    getHeaders: (req: TFrameworkReq) => Record<string, string>;
+    getMethod: (req: TFrameworkReq) => string;
+    getParams?: (req: TFrameworkReq, context?: any) => Record<string, string> | Promise<Record<string, string>>;
+    getQuery?: (req: TFrameworkReq) => Record<string, string>;
+    sendJson: (data: any, status: number) => TFrameworkRes;
+}): (innerHandler: Function) => (req: TFrameworkReq, context?: any, config?: any) => Promise<any>;

package/dist/cjs/integrations/utils/create-adapter.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Generic adapter factory - eliminates repetitive adapter code
+ * Works with any framework (Express, Fastify, Hono, Next.js, etc.)
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFrameworkAdapter = createFrameworkAdapter;
+/**
+ * Creates a framework adapter for any HTTP framework
+ * Automatically extracts headers and converts request/response
+ *
+ * @param extractors - Framework-specific extraction functions
+ * @returns Adapter function that wraps core handlers
+ *
+ * @example
+ * ```typescript
+ * const nextjsAdapter = createFrameworkAdapter({
+ *   getBody: async (req) => await req.json(),
+ *   getHeaders: (req) => Object.fromEntries(req.headers),
+ *   getMethod: (req) => req.method || "GET",
+ *   sendJson: (data, status) => NextResponse.json(data, { status })
+ * });
+ * ```
+ */
+function createFrameworkAdapter(extractors) {
+    return function adaptHandler(innerHandler) {
+        return (req, context, config) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const body = yield extractors.getBody(req);
+            const params = extractors.getParams
+                ? yield extractors.getParams(req, context)
+                : undefined;
+            const requestContext = {
+                body,
+                headers: extractors.getHeaders(req),
+                method: extractors.getMethod(req),
+                params,
+                query: (_a = extractors.getQuery) === null || _a === void 0 ? void 0 : _a.call(extractors, req),
+            };
+            const responseContext = {
+                json: (data, status = 200) => extractors.sendJson(data, status),
+                error: (message, status) => extractors.sendJson({ error: message }, status),
+            };
+            return innerHandler(requestContext, responseContext, config);
+        });
+    };
+}

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.4.1";
+export declare const SDK_VERSION = "0.5.0-alpha2";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.4.1";
+exports.SDK_VERSION = "0.5.0-alpha2";

package/dist/esm/Client.mjs

@@ -24,8 +24,8 @@ export class PaidClient {
         this._options = Object.assign(Object.assign({}, _options), { headers: mergeHeaders({
                 "X-Fern-Language": "JavaScript",
                 "X-Fern-SDK-Name": "@paid-ai/paid-node",
-                "X-Fern-SDK-Version": "0.4.1",
-                "User-Agent": "@paid-ai/paid-node/0.4.1",
+                "X-Fern-SDK-Version": "0.5.0-alpha2",
+                "User-Agent": "@paid-ai/paid-node/0.5.0-alpha2",
                 "X-Fern-Runtime": core.RUNTIME.type,
                 "X-Fern-Runtime-Version": core.RUNTIME.version,
             }, _options === null || _options === void 0 ? void 0 : _options.headers) });

package/dist/esm/index.d.mts

@@ -2,3 +2,4 @@ export * as Paid from "./api/index.mjs";
 export { PaidClient } from "./Client.mjs";
 export { PaidEnvironment } from "./environments.mjs";
 export { PaidError, PaidTimeoutError } from "./errors/index.mjs";
+export * as PaidIntegrations from "./integrations/index.mjs";

package/dist/esm/index.mjs

@@ -2,3 +2,4 @@ export * as Paid from "./api/index.mjs";
 export { PaidClient } from "./Client.mjs";
 export { PaidEnvironment } from "./environments.mjs";
 export { PaidError, PaidTimeoutError } from "./errors/index.mjs";
+export * as PaidIntegrations from "./integrations/index.mjs";

package/dist/esm/integrations/adapters/nextjs/base-adapter.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Next.js adapter for Paid SDK
+ * Converts Next.js App Router requests to framework-agnostic format
+ */
+import { NextRequest } from "next/server";
+/**
+ * Next.js adapter for App Router
+ * Handles NextRequest/NextResponse conversion to base handler format
+ */
+export declare const nextjsAdapter: (innerHandler: Function) => (req: NextRequest, context?: any, config?: any) => Promise<any>;

package/dist/esm/integrations/adapters/nextjs/base-adapter.mjs

@@ -0,0 +1,55 @@
+/**
+ * Next.js adapter for Paid SDK
+ * Converts Next.js App Router requests to framework-agnostic format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { NextResponse } from "next/server";
+import { createFrameworkAdapter } from "../../utils/create-adapter.mjs";
+/**
+ * Next.js adapter for App Router
+ * Handles NextRequest/NextResponse conversion to base handler format
+ */
+export const nextjsAdapter = createFrameworkAdapter({
+    getBody: (req) => __awaiter(void 0, void 0, void 0, function* () {
+        if (req.method === "GET" || req.method === "HEAD") {
+            return {};
+        }
+        try {
+            return yield req.json();
+        }
+        catch (error) {
+            return {};
+        }
+    }),
+    getHeaders: (req) => {
+        const headers = {};
+        req.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return headers;
+    },
+    getMethod: (req) => req.method || "GET",
+    getParams: (_req, context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!(context === null || context === void 0 ? void 0 : context.params)) {
+            return {};
+        }
+        const params = context.params instanceof Promise ? yield context.params : context.params;
+        return params || {};
+    }),
+    getQuery: (req) => {
+        const query = {};
+        req.nextUrl.searchParams.forEach((value, key) => {
+            query[key] = value;
+        });
+        return query;
+    },
+    sendJson: (data, status) => NextResponse.json(data, { status }),
+});

package/dist/esm/integrations/adapters/nextjs/index.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Next.js API Route handlers for Paid integration
+ * Drop-in handlers for Next.js App Router
+ */
+export { createActivateOrderSyncRoute, createContactsRoute, createCustomerInvoicesRoute, createCustomersRoute, createGetCustomerRoute, createOrdersRoute, createPayInvoiceRoute, createProvisioningRoute, createSetupIntentRoute, type ActivateOrderSyncRouteConfig, type OrdersRouteConfig, type ProvisioningRouteConfig, type SetupIntentRouteConfig, } from './routes.mjs';

package/dist/esm/integrations/adapters/nextjs/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Next.js API Route handlers for Paid integration
+ * Drop-in handlers for Next.js App Router
+ */
+export { createActivateOrderSyncRoute, createContactsRoute, createCustomerInvoicesRoute, createCustomersRoute, createGetCustomerRoute, createOrdersRoute, createPayInvoiceRoute, createProvisioningRoute, createSetupIntentRoute, } from './routes.mjs';

package/dist/esm/integrations/adapters/nextjs/routes.d.mts

@@ -0,0 +1,225 @@
+import { BaseHandlerConfig } from "../../utils/base-handler.mjs";
+import { OrderOptions } from "../../types.mjs";
+export interface ActivateOrderSyncRouteConfig extends BaseHandlerConfig {
+    /**
+     * Default return URL for payment flow
+     * Can be overridden by request body
+     */
+    defaultReturnUrl?: string;
+}
+/**
+ * Create a Next.js API route handler for synchronous order activation
+ *
+ * This creates an endpoint that activates an order and immediately charges
+ * the customer using a confirmation token from a payment provider.
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/orders/[orderId]/activate-sync/route.ts
+ * import { createActivateOrderSyncRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createActivateOrderSyncRoute({
+ *   defaultReturnUrl: process.env.NEXT_PUBLIC_BASE_URL + '/orders'
+ * });
+ * ```
+ *
+ * @example Client-side usage with route params
+ * ```typescript
+ * await fetch('/api/orders/ord_123/activate-sync', {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     confirmationToken: 'pi_123_secret_456',
+ *     returnUrl: 'https://example.com/return'
+ *   })
+ * });
+ * ```
+ *
+ * @example Client-side usage with body params
+ * ```typescript
+ * await fetch('/api/orders/activate-sync', {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     orderId: 'ord_123',
+ *     confirmationToken: 'pi_123_secret_456'
+ *   })
+ * });
+ * ```
+ */
+export declare function createActivateOrderSyncRoute(config?: ActivateOrderSyncRouteConfig): (request: any, context?: any) => Promise<any>;
+/**
+ * Create a Next.js API route handler for contact creation
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/contacts/route.ts
+ * import { createContactsRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createContactsRoute();
+ * ```
+ */
+export declare function createContactsRoute(config?: BaseHandlerConfig): (request: any, context?: any) => Promise<any>;
+/**
+ * Create a Next.js API route handler for fetching customer invoices
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/customers/[customerExternalId]/invoices/route.ts
+ * import { createCustomerInvoicesRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const GET = createCustomerInvoicesRoute();
+ * ```
+ */
+export declare function createCustomerInvoicesRoute(config?: BaseHandlerConfig): (request: any, context?: any) => Promise<any>;
+/**
+ * Create a Next.js API route handler for fetching a customer by external ID
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/customers/[customerExternalId]/route.ts
+ * import { createGetCustomerRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const GET = createGetCustomerRoute();
+ * ```
+ */
+export declare function createGetCustomerRoute(config?: BaseHandlerConfig): (request: any, context?: any) => Promise<any>;
+/**
+ * Create a Next.js API route handler for customer creation
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/customers/route.ts
+ * import { createCustomersRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createCustomersRoute();
+ * ```
+ *
+ * @example With custom config
+ * ```typescript
+ * export const POST = createCustomersRoute({
+ *   validate: async (body) => {
+ *     if (!body.email.includes('@company.com')) {
+ *       throw new Error('Only company emails allowed');
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare function createCustomersRoute(config?: BaseHandlerConfig): (request: any, context?: any) => Promise<any>;
+export interface OrdersRouteConfig extends BaseHandlerConfig {
+    /**
+     * Default helper options for order creation
+     */
+    helperOptions?: OrderOptions;
+}
+/**
+ * Create a Next.js API route handler for order creation
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/orders/route.ts
+ * import { createOrdersRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createOrdersRoute();
+ * ```
+ *
+ * @example With auto-activation disabled
+ * ```typescript
+ * export const POST = createOrdersRoute({
+ *   helperOptions: { autoActivate: false }
+ * });
+ * ```
+ */
+export declare function createOrdersRoute(config?: OrdersRouteConfig): (request: any, context?: any) => Promise<any>;
+/**
+ * Create a Next.js API route handler for invoice payment
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/invoices/[invoiceId]/pay/route.ts
+ * import { createPayInvoiceRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createPayInvoiceRoute();
+ * ```
+ */
+export declare function createPayInvoiceRoute(config?: BaseHandlerConfig): (request: any, context?: any) => Promise<any>;
+export interface ProvisioningRouteConfig extends BaseHandlerConfig {
+    /**
+     * Default agent external ID
+     * Can be overridden by request body
+     */
+    defaultAgentExternalId?: string;
+    /**
+     * Default order options
+     */
+    orderOptions?: OrderOptions;
+}
+/**
+ * Create a Next.js API route handler for user provisioning
+ *
+ * This creates a single endpoint that provisions a complete user
+ * with customer, contact, and optional order.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/provision/route.ts
+ * import { createProvisioningRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createProvisioningRoute({
+ *   defaultAgentExternalId: process.env.PAID_AGENT_ID
+ * });
+ * ```
+ *
+ * @example Client-side usage
+ * ```typescript
+ * await fetch('/api/provision', {
+ *   method: 'POST',
+ *   body: JSON.stringify({ email: 'user@example.com' })
+ * });
+ * ```
+ */
+export declare function createProvisioningRoute(config?: ProvisioningRouteConfig): (request: any, context?: any) => Promise<any>;
+export interface SetupIntentRouteConfig extends BaseHandlerConfig {
+    /**
+     * Default return URL for setup flow
+     * Can be overridden by request body
+     */
+    defaultReturnUrl?: string;
+}
+/**
+ * Create a Next.js API route handler for setup intent creation
+ *
+ * Setup intents are used to add payment methods without immediate charge.
+ * This is useful for saving payment methods for future billing.
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/payment-methods/setup/route.ts
+ * import { createSetupIntentRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createSetupIntentRoute({
+ *   defaultReturnUrl: process.env.NEXT_PUBLIC_BASE_URL + '/billing'
+ * });
+ * ```
+ *
+ * @example Client-side usage
+ * ```typescript
+ * await fetch('/api/payment-methods/setup', {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     customerId: 'cus_123',
+ *     confirmationToken: 'seti_123_secret_456',
+ *     returnUrl: 'https://example.com/billing',
+ *     metadata: { source: 'settings_page' }
+ *   })
+ * });
+ * ```
+ */
+export declare function createSetupIntentRoute(config?: SetupIntentRouteConfig): (request: any, context?: any) => Promise<any>;