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

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

@@ -0,0 +1,113 @@
+export interface PayInvoiceConfig {
+    apiUrl: string;
+    apiKey: string;
+    organizationId: string;
+}
+export interface PayInvoiceRequest {
+    invoiceId: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+export interface PayInvoiceResult {
+    success: boolean;
+    data?: any;
+}
+/**
+ * Pay an invoice with a payment confirmation token
+ * This helper processes payment for an existing invoice using a Stripe confirmation token.
+ *
+ * @param config - API configuration with organization context
+ * @param request - Payment request details
+ * @returns Payment result
+ *
+ * @example
+ * ```typescript
+ * const result = await payInvoice(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     invoiceId: 'inv_123',
+ *     confirmationToken: 'pm_tok_xxx',
+ *     returnUrl: 'https://example.com/thanks'
+ *   }
+ * );
+ * ```
+ */
+export declare function payInvoice(config: PayInvoiceConfig, request: PayInvoiceRequest): Promise<PayInvoiceResult>;
+interface PayInvoiceRequestWithBody {
+    invoiceId?: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+/**
+ * Create a framework-agnostic handler for invoice payment
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+export declare function createPayInvoiceHandler(): (request: import("../utils/base-handler.mjs").BaseRequestContext<PayInvoiceRequestWithBody, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;
+export interface ActivateOrderSyncConfig {
+    apiUrl: string;
+    apiKey: string;
+    organizationId: string;
+}
+export interface ActivateOrderSyncRequest {
+    orderId: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+export interface ActivateOrderSyncResult {
+    success: boolean;
+    order: any;
+    billing: any;
+}
+/**
+ * Activate an order synchronously with payment
+ *
+ * This operation activates an order and immediately charges the customer
+ * using the provided confirmation token (from Stripe or other payment provider).
+ *
+ * @param config - API configuration with organization context
+ * @param request - Activation request with order ID and confirmation token
+ * @returns Activation result with order and billing information
+ *
+ * @example
+ * ```typescript
+ * const result = await activateOrderSync(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     orderId: 'ord_123',
+ *     confirmationToken: 'pi_123_secret_456',
+ *     returnUrl: 'https://example.com/return'
+ *   }
+ * );
+ * ```
+ */
+export declare function activateOrderSync(config: ActivateOrderSyncConfig, request: ActivateOrderSyncRequest): Promise<ActivateOrderSyncResult>;
+/**
+ * Internal request body type for the handler
+ */
+interface ActivateOrderSyncRequestBody {
+    orderId?: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+/**
+ * Create a framework-agnostic handler for synchronous order activation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param defaultReturnUrl - Optional default return URL
+ * @returns Handler function
+ */
+export declare function createActivateOrderSyncHandler(defaultReturnUrl?: string): (request: import("../utils/base-handler.mjs").BaseRequestContext<ActivateOrderSyncRequestBody, 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/billing.mjs

@@ -0,0 +1,158 @@
+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";
+/**
+ * Pay an invoice with a payment confirmation token
+ * This helper processes payment for an existing invoice using a Stripe confirmation token.
+ *
+ * @param config - API configuration with organization context
+ * @param request - Payment request details
+ * @returns Payment result
+ *
+ * @example
+ * ```typescript
+ * const result = await payInvoice(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     invoiceId: 'inv_123',
+ *     confirmationToken: 'pm_tok_xxx',
+ *     returnUrl: 'https://example.com/thanks'
+ *   }
+ * );
+ * ```
+ */
+export function payInvoice(config, request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { invoiceId, confirmationToken, returnUrl } = request;
+        if (!invoiceId || !confirmationToken) {
+            throw new Error("invoiceId and confirmationToken are required");
+        }
+        const data = yield paidApiFetch(config, `/api/organizations/${config.organizationId}/invoices/${invoiceId}/pay`, {
+            method: "PUT",
+            body: Object.assign({ confirmationToken }, (returnUrl && { returnUrl })),
+        });
+        return { success: true, data };
+    });
+}
+/**
+ * Create a framework-agnostic handler for invoice payment
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+export function createPayInvoiceHandler() {
+    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 invoiceId = (params === null || params === void 0 ? void 0 : params.invoiceId) || body.invoiceId;
+        const { confirmationToken, returnUrl } = body;
+        if (!invoiceId) {
+            return { success: false, error: 'invoiceId is required', status: 400 };
+        }
+        if (!confirmationToken) {
+            return { success: false, error: 'confirmationToken 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 payInvoice({ apiUrl, apiKey, organizationId }, { invoiceId, confirmationToken, returnUrl });
+        return {
+            success: true,
+            data: result.data,
+        };
+    }), { requiredFields: ['confirmationToken'], requireOrganizationId: true });
+}
+/**
+ * Activate an order synchronously with payment
+ *
+ * This operation activates an order and immediately charges the customer
+ * using the provided confirmation token (from Stripe or other payment provider).
+ *
+ * @param config - API configuration with organization context
+ * @param request - Activation request with order ID and confirmation token
+ * @returns Activation result with order and billing information
+ *
+ * @example
+ * ```typescript
+ * const result = await activateOrderSync(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     orderId: 'ord_123',
+ *     confirmationToken: 'pi_123_secret_456',
+ *     returnUrl: 'https://example.com/return'
+ *   }
+ * );
+ * ```
+ */
+export function activateOrderSync(config, request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { orderId, confirmationToken, returnUrl } = request;
+        if (!orderId) {
+            throw new Error("orderId is required");
+        }
+        if (!confirmationToken) {
+            throw new Error("confirmationToken is required");
+        }
+        const data = yield paidApiFetch(config, `/api/organizations/${config.organizationId}/orders/${orderId}/activate-sync`, {
+            method: "POST",
+            body: Object.assign({ confirmationToken }, (returnUrl && { returnUrl })),
+        });
+        return {
+            success: true,
+            order: data.order,
+            billing: data.billing,
+        };
+    });
+}
+/**
+ * Create a framework-agnostic handler for synchronous order activation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param defaultReturnUrl - Optional default return URL
+ * @returns Handler function
+ */
+export function createActivateOrderSyncHandler(defaultReturnUrl) {
+    return createHandler((client, body, params, organizationId) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const apiKey = (_a = client._options) === null || _a === void 0 ? void 0 : _a.token;
+        const baseUrl = ((_b = client._options) === null || _b === void 0 ? void 0 : _b.baseUrl) || 'https://api.agentpaid.io/api/v1';
+        const apiUrl = baseUrl.replace('/api/v1', '');
+        const orderId = (params === null || params === void 0 ? void 0 : params.orderId) || body.orderId;
+        const result = yield activateOrderSync({ apiUrl, apiKey, organizationId: organizationId }, {
+            orderId: orderId,
+            confirmationToken: body.confirmationToken,
+            returnUrl: body.returnUrl || defaultReturnUrl,
+        });
+        return {
+            success: true,
+            data: {
+                success: true,
+                order: result.order,
+                billing: result.billing,
+                message: 'Order activated and charged successfully',
+            },
+        };
+    }), {
+        requiredFields: ['confirmationToken'],
+        requireOrganizationId: true,
+    });
+}

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

@@ -0,0 +1,66 @@
+import type { PaidClient } from "../../Client.mjs";
+import type { ContactData, ContactCreationResult, Address } from "../types.mjs";
+/**
+ * Create a contact with defaults for missing fields
+ *
+ * This helper generates reasonable placeholder values for any missing data,
+ * making it easy to create contacts for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param data - Contact data (only customerExternalId is required)
+ * @returns Created contact with ID
+ *
+ * @example
+ * ```typescript
+ * const contact = await createContactWithDefaults(client, {
+ *   customerExternalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ * // Generates: firstName, lastName, address, etc.
+ * ```
+ */
+export declare function createContactWithDefaults(client: PaidClient, data: ContactData): Promise<ContactCreationResult>;
+/**
+ * Create a contact with explicit data (NO defaults applied)
+ *
+ * Required fields: customerExternalId, email, firstName, lastName, phone, salutation,
+ * and complete billingAddress (line1, line2, city, state, zipCode, country)
+ *
+ * Use createContactWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param data - Complete contact data with ALL required fields
+ * @returns Created contact with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const contact = await createContact(client, {
+ *   customerExternalId: 'user-123',
+ *   email: 'john@example.com',
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   phone: '+1234567890',
+ *   salutation: 'Mr',
+ *   billingAddress: {
+ *     line1: '123 Main St',
+ *     line2: 'Suite 100',
+ *     city: 'San Francisco',
+ *     state: 'CA',
+ *     zipCode: '94105',
+ *     country: 'US'
+ *   }
+ * });
+ * ```
+ */
+export declare function createContact(client: PaidClient, data: Required<Omit<ContactData, 'billingAddress'>> & {
+    billingAddress: Required<Address>;
+}): Promise<ContactCreationResult>;
+/**
+ * Create a framework-agnostic handler for contact creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+export declare function createContactsHandler(): (request: import("../utils/base-handler.mjs").BaseRequestContext<ContactData, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;

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

@@ -0,0 +1,140 @@
+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";
+function generateContactDefaults(data) {
+    var _a, _b, _c, _d, _e, _f;
+    const timestamp = Date.now();
+    const email = data.email || `contact_${timestamp}@example.com`;
+    const firstName = data.firstName || "Joe";
+    const lastName = data.lastName || "Bloggs";
+    const phone = data.phone || "";
+    const salutation = data.salutation || "Mr";
+    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 {
+        customerExternalId: data.customerExternalId,
+        email,
+        firstName,
+        lastName,
+        phone,
+        salutation,
+        billingAddress,
+    };
+}
+/**
+ * Internal helper to create a contact
+ */
+function createContactInternal(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contact = yield client.contacts.create({
+            customerExternalId: data.customerExternalId,
+            salutation: data.salutation,
+            firstName: data.firstName,
+            lastName: data.lastName,
+            email: data.email,
+            phone: data.phone,
+            billingStreet: data.billingAddress.line1,
+            billingCity: data.billingAddress.city,
+            billingCountry: data.billingAddress.country,
+            billingPostalCode: data.billingAddress.zipCode,
+        });
+        if (!contact.id) {
+            throw new Error("Contact created but missing ID");
+        }
+        return {
+            id: contact.id,
+        };
+    });
+}
+/**
+ * Create a contact with defaults for missing fields
+ *
+ * This helper generates reasonable placeholder values for any missing data,
+ * making it easy to create contacts for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param data - Contact data (only customerExternalId is required)
+ * @returns Created contact with ID
+ *
+ * @example
+ * ```typescript
+ * const contact = await createContactWithDefaults(client, {
+ *   customerExternalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ * // Generates: firstName, lastName, address, etc.
+ * ```
+ */
+export function createContactWithDefaults(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!data.customerExternalId) {
+            throw new Error("customerExternalId is required");
+        }
+        const completeData = generateContactDefaults(data);
+        return createContactInternal(client, completeData);
+    });
+}
+/**
+ * Create a contact with explicit data (NO defaults applied)
+ *
+ * Required fields: customerExternalId, email, firstName, lastName, phone, salutation,
+ * and complete billingAddress (line1, line2, city, state, zipCode, country)
+ *
+ * Use createContactWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param data - Complete contact data with ALL required fields
+ * @returns Created contact with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const contact = await createContact(client, {
+ *   customerExternalId: 'user-123',
+ *   email: 'john@example.com',
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   phone: '+1234567890',
+ *   salutation: 'Mr',
+ *   billingAddress: {
+ *     line1: '123 Main St',
+ *     line2: 'Suite 100',
+ *     city: 'San Francisco',
+ *     state: 'CA',
+ *     zipCode: '94105',
+ *     country: 'US'
+ *   }
+ * });
+ * ```
+ */
+export function createContact(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return createContactInternal(client, data);
+    });
+}
+/**
+ * Create a framework-agnostic handler for contact creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+export function createContactsHandler() {
+    return createHandler((client, body) => __awaiter(this, void 0, void 0, function* () {
+        const contact = yield createContactWithDefaults(client, body);
+        return { success: true, data: contact };
+    }), { requiredFields: ['customerExternalId'] });
+}

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

@@ -0,0 +1,63 @@
+import { PaidClient } from "../../Client.mjs";
+import type { CustomerData, CustomerCreationResult, Address } from "../types.mjs";
+/**
+ * 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 declare function createCustomerWithDefaults(client: PaidClient, data: CustomerData): Promise<CustomerCreationResult>;
+/**
+ * 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 declare function createCustomer(client: PaidClient, data: Required<Omit<CustomerData, 'firstName' | 'lastName' | 'company' | 'phone' | 'metadata' | 'billingAddress'>> & {
+    billingAddress: Required<Address>;
+}): Promise<CustomerCreationResult>;
+/**
+ * Create a framework-agnostic handler for customer creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+export declare function createCustomersHandler(): (request: import("../utils/base-handler.mjs").BaseRequestContext<CustomerData, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;

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

@@ -0,0 +1,145 @@
+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'] });
+}