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

package/dist/esm/integrations/controllers/customers.mjs

@@ -0,0 +1,199 @@
+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 { createHandler } from "../utils/base-handler.mjs";
+/**
+ * Generate placeholder values for missing customer fields
+ * Creates valid but fake data for rapid prototyping
+ */
+function generateCustomerDefaults(data) {
+    var _a, _b, _c, _d, _e, _f;
+    const timestamp = Date.now();
+    const randomId = Math.random().toString(36).substring(7);
+    const email = data.email || `user_${timestamp}@example.com`;
+    const name = data.name || `User ${randomId}`;
+    const nameParts = name.split(" ");
+    const firstName = data.firstName || nameParts[0] || "Joe";
+    const lastName = data.lastName || nameParts.slice(1).join(" ") || "Bloggs";
+    const billingAddress = {
+        line1: ((_a = data.billingAddress) === null || _a === void 0 ? void 0 : _a.line1) || "123 Placeholder Street",
+        line2: ((_b = data.billingAddress) === null || _b === void 0 ? void 0 : _b.line2) || "",
+        city: ((_c = data.billingAddress) === null || _c === void 0 ? void 0 : _c.city) || "London",
+        state: ((_d = data.billingAddress) === null || _d === void 0 ? void 0 : _d.state) || "London",
+        zipCode: ((_e = data.billingAddress) === null || _e === void 0 ? void 0 : _e.zipCode) || "SW1A 1AA",
+        country: ((_f = data.billingAddress) === null || _f === void 0 ? void 0 : _f.country) || "UK",
+    };
+    return {
+        externalId: data.externalId,
+        email,
+        name,
+        firstName,
+        lastName,
+        company: data.company || "",
+        phone: data.phone || "",
+        billingAddress,
+        metadata: data.metadata || {},
+    };
+}
+/**
+ * Internal helper to create a customer
+ */
+function createCustomerInternal(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const customer = yield client.customers.create({
+            externalId: data.externalId,
+            name: data.name,
+            billingAddress: {
+                line1: data.billingAddress.line1,
+                line2: data.billingAddress.line2,
+                city: data.billingAddress.city,
+                state: data.billingAddress.state,
+                zipCode: data.billingAddress.zipCode,
+                country: data.billingAddress.country,
+            },
+        });
+        if (!customer.id) {
+            throw new Error("Customer created but missing ID");
+        }
+        return {
+            id: customer.id,
+            externalId: data.externalId,
+        };
+    });
+}
+/**
+ * Create a customer with defaults for missing fields
+ *
+ * This helper generates reasonable placeholder values for any missing data,
+ * making it easy to create customers for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param data - Customer data (only externalId is required)
+ * @returns Created customer with ID
+ *
+ * @example
+ * ```typescript
+ * const customer = await createCustomerWithDefaults(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ * // Generates: name, address, etc.
+ * ```
+ */
+export function createCustomerWithDefaults(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const completeData = generateCustomerDefaults(data);
+        return createCustomerInternal(client, completeData);
+    });
+}
+/**
+ * Create a customer with explicit data (NO defaults applied)
+ *
+ * Required fields: externalId, name, email, and complete billingAddress
+ * (line1, line2, city, state, zipCode, country)
+ *
+ * Use createCustomerWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param data - Complete customer data with ALL required fields
+ * @returns Created customer with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const customer = await createCustomer(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com',
+ *   name: 'John Doe',
+ *   billingAddress: {
+ *     line1: '123 Main St',
+ *     line2: '',
+ *     city: 'San Francisco',
+ *     state: 'CA',
+ *     zipCode: '94105',
+ *     country: 'US'
+ *   }
+ * });
+ * ```
+ */
+export function createCustomer(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return createCustomerInternal(client, data);
+    });
+}
+/**
+ * Create a framework-agnostic handler for customer creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+export function createCustomersHandler() {
+    return createHandler((client, body) => __awaiter(this, void 0, void 0, function* () {
+        if (!body.externalId) {
+            throw new Error("externalId is required");
+        }
+        const customer = yield createCustomerWithDefaults(client, body);
+        return { success: true, data: customer };
+    }), { requiredFields: ['externalId'] });
+}
+/**
+ * Get a customer by external ID
+ *
+ * @param client - PaidClient instance
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer data
+ *
+ * @example
+ * ```typescript
+ * const customer = await getCustomer(client, 'user-123');
+ * console.log(customer.name, customer.email);
+ * ```
+ */
+export function getCustomer(client, customerExternalId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const customer = yield client.customers.getByExternalId(customerExternalId);
+        return customer;
+    });
+}
+/**
+ * Create a framework-agnostic handler for fetching a customer by external ID
+ *
+ * This handler can be used with any framework adapter.
+ * The customer external ID should be provided either in params or query string.
+ *
+ * @returns Handler function
+ *
+ * @example
+ * ```typescript
+ * // In Next.js route: /api/customers/[customerExternalId]/route.ts
+ * import { createGetCustomerHandler } from '@paid-ai/paid-node/integrations';
+ * import { nextjsAdapter } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * const handler = createGetCustomerHandler();
+ * export const GET = nextjsAdapter(handler);
+ * ```
+ */
+export function createGetCustomerHandler() {
+    return createHandler((client, _body, params) => __awaiter(this, void 0, void 0, function* () {
+        const customerExternalId = params === null || params === void 0 ? void 0 : params.customerExternalId;
+        if (!customerExternalId) {
+            return {
+                success: false,
+                error: "customerExternalId is required",
+                status: 400,
+            };
+        }
+        const customer = yield getCustomer(client, customerExternalId);
+        return { success: true, data: customer };
+    }), {
+        allowedMethods: ['GET'],
+        requireOrganizationId: false,
+    });
+}

package/dist/esm/integrations/controllers/index.d.mts

@@ -0,0 +1,6 @@
+export { createCustomer, createCustomerWithDefaults, getCustomer, createGetCustomerHandler, createCustomersHandler, } from "./customers.mjs";
+export { createContact, createContactWithDefaults, createContactsHandler, } from "./contacts.mjs";
+export { createOrder, createOrderWithDefaults, createOrdersHandler, } from "./orders.mjs";
+export { payInvoice, createPayInvoiceHandler, type PayInvoiceConfig, type PayInvoiceRequest, type PayInvoiceResult, activateOrderSync, createActivateOrderSyncHandler, type ActivateOrderSyncConfig, type ActivateOrderSyncRequest, type ActivateOrderSyncResult, createSetupIntent, createSetupIntentHandler, type SetupIntentConfig, type SetupIntentRequest, type SetupIntentResponse, } from "./billing.mjs";
+export { getCustomerInvoices, createCustomerInvoicesHandler, type CustomerInvoicesResult, } from "./invoices.mjs";
+export { provisionNewUser, createProvisioningHandler, } from "./provision-users.mjs";

package/dist/esm/integrations/controllers/index.mjs

@@ -0,0 +1,6 @@
+export { createCustomer, createCustomerWithDefaults, getCustomer, createGetCustomerHandler, createCustomersHandler, } from "./customers.mjs";
+export { createContact, createContactWithDefaults, createContactsHandler, } from "./contacts.mjs";
+export { createOrder, createOrderWithDefaults, createOrdersHandler, } from "./orders.mjs";
+export { payInvoice, createPayInvoiceHandler, activateOrderSync, createActivateOrderSyncHandler, createSetupIntent, createSetupIntentHandler, } from "./billing.mjs";
+export { getCustomerInvoices, createCustomerInvoicesHandler, } from "./invoices.mjs";
+export { provisionNewUser, createProvisioningHandler, } from "./provision-users.mjs";

package/dist/esm/integrations/controllers/invoices.d.mts

@@ -0,0 +1,40 @@
+import { PayInvoiceConfig } from "./billing.mjs";
+export interface CustomerInvoicesResult {
+    data: any[];
+}
+/**
+ * Get customer invoices
+ * Fetches all invoices for a customer by their external ID.
+ *
+ * @param config - API configuration with organization context
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer invoices
+ *
+ * @example
+ * ```typescript
+ * const result = await getCustomerInvoices(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   'user-123'
+ * );
+ *
+ * console.log(`Found ${result.data.length} invoices`);
+ * ```
+ */
+export declare function getCustomerInvoices(config: PayInvoiceConfig, customerExternalId: string): Promise<CustomerInvoicesResult>;
+interface CustomerInvoicesRequest {
+    customerExternalId: string;
+}
+/**
+ * Create a framework-agnostic handler for fetching customer invoices
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+export declare function createCustomerInvoicesHandler(): (request: import("../utils/base-handler.mjs").BaseRequestContext<CustomerInvoicesRequest, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;
+export {};

package/dist/esm/integrations/controllers/invoices.mjs

@@ -0,0 +1,68 @@
+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 { paidApiFetch } from "../utils/api-fetch.mjs";
+import { createHandler } from "../utils/base-handler.mjs";
+/**
+ * Get customer invoices
+ * Fetches all invoices for a customer by their external ID.
+ *
+ * @param config - API configuration with organization context
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer invoices
+ *
+ * @example
+ * ```typescript
+ * const result = await getCustomerInvoices(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   'user-123'
+ * );
+ *
+ * console.log(`Found ${result.data.length} invoices`);
+ * ```
+ */
+export function getCustomerInvoices(config, customerExternalId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!customerExternalId) {
+            throw new Error("customerExternalId is required");
+        }
+        const data = yield paidApiFetch(config, `/api/organizations/${config.organizationId}/customer/external/${customerExternalId}/invoices`, { method: "GET" });
+        return { data: data.data || data || [] };
+    });
+}
+/**
+ * Create a framework-agnostic handler for fetching customer invoices
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+export function createCustomerInvoicesHandler() {
+    return createHandler((_client, _body, params, organizationId) => __awaiter(this, void 0, void 0, function* () {
+        if (!organizationId) {
+            return { success: false, error: 'Organization ID not found', status: 500 };
+        }
+        const customerExternalId = params === null || params === void 0 ? void 0 : params.customerExternalId;
+        if (!customerExternalId) {
+            return { success: false, error: 'customerExternalId is required', status: 400 };
+        }
+        const apiKey = process.env.PAID_API_KEY || '';
+        const apiUrl = process.env.PAID_API_URL || 'https://api.agentpaid.io';
+        const result = yield getCustomerInvoices({ apiUrl, apiKey, organizationId }, customerExternalId);
+        return {
+            success: true,
+            data: result.data,
+        };
+    }), { allowedMethods: ['GET'], requireOrganizationId: true });
+}

package/dist/esm/integrations/controllers/orders.d.mts

@@ -0,0 +1,72 @@
+import type { PaidClient } from "../../Client.mjs";
+import type { OrderConfig, OrderCreationResult, OrderOptions } from "../types.mjs";
+/**
+ * Create an order with defaults for missing fields
+ *
+ * This helper generates reasonable defaults for dates, names, and other fields,
+ * making it easy to create orders for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param config - Order configuration (customerId, customerExternalId, agentExternalId required)
+ * @param options - Additional options for order creation
+ * @returns Created order with ID
+ *
+ * @example
+ * ```typescript
+ * const order = await createOrderWithDefaults(client, {
+ *   customerId: 'cus_123',
+ *   customerExternalId: 'user-123',
+ *   agentExternalId: 'agent-prod'
+ * });
+ * // Generates: startDate, endDate (1 year), name, description, currency (USD)
+ * ```
+ */
+export declare function createOrderWithDefaults(client: PaidClient, config: OrderConfig, options?: OrderOptions): Promise<OrderCreationResult>;
+/**
+ * Create an order with explicit configuration (NO defaults applied)
+ *
+ * Required fields: customerId, customerExternalId, agentExternalId, name, description,
+ * startDate, endDate, currency, orderLines
+ *
+ * Use createOrderWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param config - Complete order configuration with ALL required fields
+ * @param options - Additional options for order creation
+ * @returns Created order with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const order = await createOrder(client, {
+ *   customerId: 'cus_123',
+ *   customerExternalId: 'user-123',
+ *   billingContactId: 'contact_123',
+ *   agentExternalId: 'agent-prod',
+ *   name: 'Pro Plan Subscription',
+ *   description: 'Monthly subscription to Pro plan',
+ *   startDate: '2024-01-01',
+ *   endDate: '2025-01-01',
+ *   currency: 'USD',
+ *   orderLines: [{
+ *     agentExternalId: 'agent-prod',
+ *     name: 'Pro Plan',
+ *     description: 'Pro plan features'
+ *   }]
+ * }, { autoActivate: true });
+ * ```
+ */
+export declare function createOrder(client: PaidClient, config: Required<OrderConfig>, options?: OrderOptions): Promise<OrderCreationResult>;
+interface OrderRequest extends OrderConfig {
+    autoActivate?: boolean;
+}
+/**
+ * Create a framework-agnostic handler for order creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param helperOptions - Default options for order creation
+ * @returns Handler function
+ */
+export declare function createOrdersHandler(helperOptions?: OrderOptions): (request: import("../utils/base-handler.mjs").BaseRequestContext<OrderRequest, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;
+export {};

package/dist/esm/integrations/controllers/orders.mjs

@@ -0,0 +1,189 @@
+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 { createHandler } from "../utils/base-handler.mjs";
+/**
+ * Generate default values for missing order fields
+ */
+function generateOrderDefaults(config, options = {}) {
+    var _a;
+    const { defaultDurationDays = 365 } = options;
+    const startDate = config.startDate || new Date().toISOString().split("T")[0];
+    const endDate = config.endDate ||
+        new Date(Date.now() + defaultDurationDays * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .split("T")[0];
+    const name = config.name || "Subscription Order";
+    const description = config.description || "Annual subscription";
+    const currency = config.currency || "USD";
+    const orderLines = ((_a = config.orderLines) === null || _a === void 0 ? void 0 : _a.map(line => ({
+        agentExternalId: line.agentExternalId,
+        name: line.name || name,
+        description: line.description || description,
+    }))) || [{
+            agentExternalId: config.agentExternalId,
+            name,
+            description,
+        }];
+    return {
+        customerId: config.customerId,
+        customerExternalId: config.customerExternalId,
+        billingContactId: config.billingContactId,
+        agentExternalId: config.agentExternalId,
+        name,
+        description,
+        startDate,
+        endDate,
+        currency,
+        orderLines,
+    };
+}
+/**
+ * Internal helper to create and optionally activate an order
+ */
+function createAndActivateOrder(client, config, autoActivate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const order = yield client.orders.create({
+            customerId: config.customerId,
+            customerExternalId: config.customerExternalId,
+            billingContactId: config.billingContactId,
+            name: config.name,
+            description: config.description,
+            startDate: config.startDate,
+            endDate: config.endDate,
+            currency: config.currency,
+            orderLines: config.orderLines.map(line => {
+                const orderLine = { agentExternalId: line.agentExternalId };
+                if (line.name)
+                    orderLine.name = line.name;
+                if (line.description)
+                    orderLine.description = line.description;
+                return orderLine;
+            }),
+        });
+        if (!order.id) {
+            throw new Error("Order created but missing ID");
+        }
+        if (autoActivate && order.creationState === "draft") {
+            try {
+                yield client.orders.activate(order.id);
+                return {
+                    id: order.id,
+                    creationState: "active",
+                };
+            }
+            catch (activationError) {
+                console.error(`Error activating order ${order.id}:`, activationError instanceof Error
+                    ? activationError.message
+                    : "Unknown error");
+                return {
+                    id: order.id,
+                    creationState: order.creationState,
+                };
+            }
+        }
+        return {
+            id: order.id,
+            creationState: order.creationState,
+        };
+    });
+}
+/**
+ * Create an order with defaults for missing fields
+ *
+ * This helper generates reasonable defaults for dates, names, and other fields,
+ * making it easy to create orders for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param config - Order configuration (customerId, customerExternalId, agentExternalId required)
+ * @param options - Additional options for order creation
+ * @returns Created order with ID
+ *
+ * @example
+ * ```typescript
+ * const order = await createOrderWithDefaults(client, {
+ *   customerId: 'cus_123',
+ *   customerExternalId: 'user-123',
+ *   agentExternalId: 'agent-prod'
+ * });
+ * // Generates: startDate, endDate (1 year), name, description, currency (USD)
+ * ```
+ */
+export function createOrderWithDefaults(client_1, config_1) {
+    return __awaiter(this, arguments, void 0, function* (client, config, options = {}) {
+        const { autoActivate = true } = options;
+        const completeConfig = generateOrderDefaults(config, options);
+        return createAndActivateOrder(client, completeConfig, autoActivate);
+    });
+}
+/**
+ * Create an order with explicit configuration (NO defaults applied)
+ *
+ * Required fields: customerId, customerExternalId, agentExternalId, name, description,
+ * startDate, endDate, currency, orderLines
+ *
+ * Use createOrderWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param config - Complete order configuration with ALL required fields
+ * @param options - Additional options for order creation
+ * @returns Created order with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const order = await createOrder(client, {
+ *   customerId: 'cus_123',
+ *   customerExternalId: 'user-123',
+ *   billingContactId: 'contact_123',
+ *   agentExternalId: 'agent-prod',
+ *   name: 'Pro Plan Subscription',
+ *   description: 'Monthly subscription to Pro plan',
+ *   startDate: '2024-01-01',
+ *   endDate: '2025-01-01',
+ *   currency: 'USD',
+ *   orderLines: [{
+ *     agentExternalId: 'agent-prod',
+ *     name: 'Pro Plan',
+ *     description: 'Pro plan features'
+ *   }]
+ * }, { autoActivate: true });
+ * ```
+ */
+export function createOrder(client_1, config_1) {
+    return __awaiter(this, arguments, void 0, function* (client, config, options = {}) {
+        const { autoActivate = true } = options;
+        return createAndActivateOrder(client, config, autoActivate);
+    });
+}
+/**
+ * Create a framework-agnostic handler for order creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param helperOptions - Default options for order creation
+ * @returns Handler function
+ */
+export function createOrdersHandler(helperOptions) {
+    return createHandler((client, body) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!body.customerId) {
+            throw new Error("customerId is required");
+        }
+        if (!body.customerExternalId) {
+            throw new Error("customerExternalId is required");
+        }
+        if (!body.agentExternalId) {
+            throw new Error("agentExternalId is required");
+        }
+        const orderOptions = Object.assign(Object.assign({}, helperOptions), { autoActivate: (_b = (_a = body.autoActivate) !== null && _a !== void 0 ? _a : helperOptions === null || helperOptions === void 0 ? void 0 : helperOptions.autoActivate) !== null && _b !== void 0 ? _b : true });
+        const order = yield createOrderWithDefaults(client, body, orderOptions);
+        return { success: true, data: order };
+    }), { requiredFields: ['customerId', 'customerExternalId', 'agentExternalId'] });
+}

package/dist/esm/integrations/controllers/provision-users.d.mts

@@ -0,0 +1,62 @@
+/**
+ * Provisioning helpers for Paid SDK
+ * Orchestrates customer + contact + order creation in one operation
+ */
+import type { PaidClient } from "../../Client.mjs";
+import type { OrderOptions, ProvisioningConfig, ProvisioningResult } from "../types.mjs";
+/**
+ * Provision a new user with customer, contact, and optionally order
+ *
+ * This is a high-level helper that orchestrates the creation of all
+ * necessary Paid entities for a new user in one operation.
+ *
+ * @param client - PaidClient instance
+ * @param config - Provisioning configuration
+ * @returns Result with created customer, contact, and optional order
+ *
+ * @example
+ * ```typescript
+ * const result = await provisionNewUser(client, {
+ *   customer: {
+ *     externalId: 'user-123',
+ *     email: 'user@example.com'
+ *   },
+ *   agentExternalId: 'agent-prod'
+ * });
+ * // Creates customer, contact, and order with defaults
+ * ```
+ */
+export declare function provisionNewUser(client: PaidClient, config: ProvisioningConfig): Promise<ProvisioningResult>;
+/**
+ * Create a framework-agnostic handler for user provisioning
+ *
+ * This handler can be used with any framework adapter.
+ * Accepts partial provisioning configuration and fills in defaults for missing fields.
+ *
+ * @param orderOptions - Optional default order creation options
+ * @param defaultAgentExternalId - Optional default agent external ID
+ * @returns Handler function
+ *
+ * @example
+ * ```typescript
+ * // Minimal - just externalId and email
+ * {
+ *   customer: { externalId: 'org-123', email: 'user@example.com' }
+ * }
+ *
+ * // With full customer data
+ * {
+ *   customer: {
+ *     externalId: 'org-123',
+ *     email: 'user@example.com',
+ *     name: 'Acme Corp',
+ *     billingAddress: { line1: '123 Main St', city: 'NYC', ... }
+ *   },
+ *   contact: {
+ *     firstName: 'John',
+ *     lastName: 'Doe'
+ *   }
+ * }
+ * ```
+ */
+export declare function createProvisioningHandler(orderOptions?: OrderOptions, defaultAgentExternalId?: string): (request: import("../utils/base-handler.mjs").BaseRequestContext<Partial<ProvisioningConfig>, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;