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

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

@@ -0,0 +1,6 @@
+export { createCustomer, createCustomerWithDefaults, 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, } 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, createCustomersHandler, } from "./customers.mjs";
+export { createContact, createContactWithDefaults, createContactsHandler, } from "./contacts.mjs";
+export { createOrder, createOrderWithDefaults, createOrdersHandler, } from "./orders.mjs";
+export { payInvoice, createPayInvoiceHandler, activateOrderSync, createActivateOrderSyncHandler, } 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>;

package/dist/esm/integrations/controllers/provision-users.mjs

@@ -0,0 +1,126 @@
+/**
+ * Provisioning helpers for Paid SDK
+ * Orchestrates customer + contact + order creation in one operation
+ */
+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 { createCustomerWithDefaults } from "./customers.mjs";
+import { createContactWithDefaults } from "./contacts.mjs";
+import { createOrderWithDefaults } from "./orders.mjs";
+import { createHandler } from "../utils/base-handler.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 function provisionNewUser(client, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const customer = yield createCustomerWithDefaults(client, config.customer);
+        const contactData = {
+            customerExternalId: config.customer.externalId,
+            email: ((_a = config.contact) === null || _a === void 0 ? void 0 : _a.email) || config.customer.email,
+            firstName: (_b = config.contact) === null || _b === void 0 ? void 0 : _b.firstName,
+            lastName: (_c = config.contact) === null || _c === void 0 ? void 0 : _c.lastName,
+            phone: (_d = config.contact) === null || _d === void 0 ? void 0 : _d.phone,
+            billingAddress: (_e = config.contact) === null || _e === void 0 ? void 0 : _e.billingAddress,
+            salutation: (_f = config.contact) === null || _f === void 0 ? void 0 : _f.salutation,
+        };
+        const contact = yield createContactWithDefaults(client, contactData);
+        let order;
+        if (config.agentExternalId) {
+            order = yield createOrderWithDefaults(client, {
+                customerId: customer.id,
+                customerExternalId: config.customer.externalId,
+                agentExternalId: config.agentExternalId,
+                billingContactId: contact.id,
+            }, config.orderOptions);
+        }
+        return {
+            customer,
+            contact,
+            order,
+        };
+    });
+}
+/**
+ * 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 function createProvisioningHandler(orderOptions, defaultAgentExternalId) {
+    return createHandler((client, body) => __awaiter(this, void 0, void 0, function* () {
+        if (!body.customer) {
+            return {
+                success: false,
+                error: "'customer' is required",
+                status: 400,
+            };
+        }
+        const effectiveAgentId = body.agentExternalId ||
+            defaultAgentExternalId ||
+            process.env.NEXT_PUBLIC_PAID_AGENT_ID ||
+            process.env.PAID_AGENT_ID;
+        const result = yield provisionNewUser(client, {
+            customer: body.customer,
+            contact: body.contact,
+            agentExternalId: effectiveAgentId,
+            orderOptions: body.orderOptions || orderOptions,
+        });
+        return {
+            success: true,
+            data: result,
+        };
+    }), { requiredFields: [] });
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Paid SDK Integrations
+ *
+ * This module provides simplified helpers for common Paid operations
+ * with defaults and reduced boilerplate.
+ *
+ * @module integrations
+ *
+ * @example
+ * ```typescript
+ * import { PaidClient } from '@paid-ai/paid-node';
+ * import { createCustomerWithDefaults, createOrderWithDefaults } from '@paid-ai/paid-node/integrations';
+ *
+ * const client = new PaidClient({ token: 'pk_xxx' });
+ *
+ * const customer = await createCustomerWithDefaults(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ *
+ * const order = await createOrderWithDefaults(client, {
+ *   customerId: customer.id,
+ *   customerExternalId: 'user-123',
+ *   agentExternalId: 'agent-prod'
+ * });
+ * ```
+ */
+export * from "./controllers/index.mjs";
+export type { Address, CustomerData, CompleteCustomerData, ContactData, OrderConfig, CompleteOrderConfig, OrderLineConfig, OrderOptions as HelperOptions, CustomerCreationResult, ContactCreationResult, OrderCreationResult, ProvisioningConfig, ProvisioningResult, } from "./types.mjs";

package/dist/esm/integrations/index.mjs

@@ -0,0 +1,28 @@
+/**
+ * Paid SDK Integrations
+ *
+ * This module provides simplified helpers for common Paid operations
+ * with defaults and reduced boilerplate.
+ *
+ * @module integrations
+ *
+ * @example
+ * ```typescript
+ * import { PaidClient } from '@paid-ai/paid-node';
+ * import { createCustomerWithDefaults, createOrderWithDefaults } from '@paid-ai/paid-node/integrations';
+ *
+ * const client = new PaidClient({ token: 'pk_xxx' });
+ *
+ * const customer = await createCustomerWithDefaults(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ *
+ * const order = await createOrderWithDefaults(client, {
+ *   customerId: customer.id,
+ *   customerExternalId: 'user-123',
+ *   agentExternalId: 'agent-prod'
+ * });
+ * ```
+ */
+export * from "./controllers/index.mjs";