@paid-ai/paid-node 0.0.8 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Agent Paid Ltd 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,28 +1,45 @@
-# Paid TypeScript Library
-
-[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2FAgentPaid%2Fpaid-node)
-[![npm shield](https://img.shields.io/npm/v/@paid-ai/paid-node)](https://www.npmjs.com/package/@paid-ai/paid-node)
 
+<div align="center">
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="./assets/paid_light.svg" width=600>
+        <source media="(prefers-color-scheme: light)" srcset="./assets/paid_dark.svg" width=600>
+        <img alt="Fallback image description" src="./assets/paid_light.svg" width=600>
+    </picture>
+</div>
+
+#
+
+<div align="center">
+    <a href="https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2FAgentPaid%2Fpaid-node">
+        <img src="https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen" alt="fern shield">
+    </a>
+    <a href="https://www.npmjs.com/package/@paid-ai/paid-node">
+        <img src="https://img.shields.io/npm/v/@paid-ai/paid-node" alt="npm shield">
+    </a>
+</div>
+
+Paid is the all-in-one, drop-in Business Engine for AI Agents that handles your pricing, subscriptions, margins, billing, and renewals with just 5 lines of code.
 The Paid TypeScript library provides convenient access to the Paid API from TypeScript.
 
+## Documentation
+
+See the full API docs [here](https://paid.docs.buildwithfern.com/api-reference/api-reference/customers/list)
+
 ## Installation
 
 ```sh
-npm i -s @paid-ai/paid-node
+npm install -s @paid-ai/paid-node
 ```
 
-## Reference
-
-A full reference for this library is available [here](https://github.com/AgentPaid/paid-node/blob/HEAD/./reference.md).
-
 ## Usage
 
-Instantiate and use the client with the following:
+The client needs to be configured with your account's API key, which is available in the [Paid dashboard](https://app.paid.ai/agent-integration/api-keys).
 
 ```typescript
 import { PaidClient } from "@paid-ai/paid-node";
 
-const client = new PaidClient({ token: "YOUR_TOKEN" });
+const client = new PaidClient({ token: "API_KEY" });
+
 await client.customers.create({
     name: "name",
 });
@@ -61,6 +78,241 @@ try {
 }
 ```
 
+## Logging
+Logs are silent by default.
+
+To enable logs, set the `PAID_LOG_LEVEL` environment variable. Available levels include:
+`error`, `warn`, `info`, `http`, `verbose`, `debug`, and `silly`.
+
+Example: `PAID_LOG_LEVEL=debug node your-app.js`
+
+## Cost Tracking via OTEL tracing
+
+You can track usage costs by using Paid wrappers around your AI provider's SDK.
+As of now, the following SDKs' APIs are wrapped:
+
+```
+openai
+anthropic
+mistral
+langchain (as a callback)
+vercel (Vercel AI SDK)
+```
+
+### Using the Paid wrappers
+
+Example usage with OpenAI:
+
+```typescript
+import { PaidClient } from "@paid-ai/paid-node";
+import { PaidOpenAI } from "@paid-ai/paid-node/openai";
+import OpenAI from "openai";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+
+    // Initialize cost tracking
+    await client.initializeTracing();
+
+    // Wrap OpenAI in paid wrapper
+    const openaiClient = new OpenAI({ apiKey: "<your_openai_api_key>" });
+    const paidOpenAI = new PaidOpenAI(openaiClient);
+
+    // Trace the call
+    await client.trace("<your_external_customer_id>", async () => {
+        const response = await paidOpenAI.images.generate({
+            prompt: "A beautiful sunset over the mountains",
+            n: 1,
+            size: "256x256"
+        });
+        if (response.data) {
+            console.log("Image generation:", response.data[0].url);
+        }
+    }, "<optional_external_agent_id>");
+}
+```
+
+## Signaling via OTEL tracing
+
+A more reliable and user-friendly way to send signals is to send them via OTEL tracing.
+This allows you to send signals with less arguments and boilerplate as the information is available in the tracing context `Paid.trace()`.
+The interface is `Paid.signal()`, which takes in signal name, optional data, and a flag that attaches costs from the same trace.
+`Paid.signal()` has to be called within a trace - meaning inside of a callback to `Paid.trace()`.
+In contrast to `Paid.usage.recordBulk()`, `Paid.signal()` is using OpenTelemetry to provide reliable delivery.
+
+Here's an example of how to use it:
+
+```typescript
+import { PaidClient } from "@paid-ai/paid-node";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+
+    // Initialize tracing
+    await client.initializeTracing();
+
+    // Trace the call
+    await client.trace("<your_external_customer_id>", async () => {
+        // ...do some work...
+        client.signal("<your_signal_name>", { /* optional data */ });
+    }, "<your_external_agent_id>"); // external_agent_id is required for signals
+}
+```
+
+### Signal-costs - Attaching cost traces to a signal
+
+If you want a signal to carry information about costs,
+then the signal should be sent from the same tracing context
+as the wrappers that recorded those costs.
+
+This will look something like this:
+
+```typescript
+import { PaidClient } from "@paid-ai/paid-node";
+import { PaidOpenAI } from "@paid-ai/paid-node/openai";
+import OpenAI from "openai";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+    await client.initializeTracing();
+
+    const openaiClient = new OpenAI({ apiKey: "<your_openai_api_key>" });
+    const paidOpenAI = new PaidOpenAI(openaiClient);
+
+    await client.trace("<your_external_customer_id>", async () => {
+        // ... your workflow logic
+        // ... your AI calls made through Paid wrappers
+        const response = await paidOpenAI.chat.completions.create({
+            model: "gpt-4",
+            messages: [{ role: "user", content: "Hello!" }]
+        });
+
+        // Send signal with cost tracing enabled
+        client.signal(
+            "<your_signal_name>",
+            true, // enableCostTracing - set this flag to associate it with costs
+            { /* optional data */ }
+        );
+
+        // ... your workflow logic
+        // ... your AI calls made through Paid wrappers (can be sent after the signal too)
+    }, "<your_external_agent_id>");
+}
+```
+
+Then, all of the costs traced in `client.trace()` context are related to that signal.
+
+## Manual Cost Tracking
+
+If you would prefer to not use Paid to track your costs automatically but you want to send us the costs yourself,
+then you can use manual cost tracking mechanism. Just attach the cost information in the following format to a signal payload:
+
+```typescript
+import { PaidClient, Paid } from "@paid-ai/paid-node";
+
+const client = new PaidClient({ token: "<your_paid_api_key>" });
+
+const signal: Paid.Signal = {
+    event_name: "<your_signal_name>",
+    agent_id: "<your_agent_id>",
+    customer_id: "<your_external_customer_id>",
+    data: {
+        costData: {
+            vendor: "<any_vendor_name>", // can be anything, traces are grouped by vendors in the UI
+            cost: {
+                amount: 0.002,
+                currency: "USD"
+            },
+            "gen_ai.response.model": "<ai_model_name>",
+        }
+    }
+};
+
+await client.usage.recordBulk({ signals: [signal] });
+await client.usage.flush(); // need to flush to send usage immediately
+```
+
+Alternatively the same `costData` payload can be passed to OTLP signaling mechanism:
+
+```typescript
+import { PaidClient } from "@paid-ai/paid-node";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+    await client.initializeTracing();
+
+    await client.trace("<your_external_customer_id>", async () => {
+        // ...do some work...
+        client.signal("<your_signal_name>", {
+            costData: {
+                vendor: "<any_vendor_name>", // can be anything, traces are grouped by vendors in the UI
+                cost: {
+                    amount: 0.002,
+                    currency: "USD"
+                },
+                "gen_ai.response.model": "<ai_model_name>",
+            }
+        });
+    }, "<your_external_agent_id>");
+}
+```
+
+### Manual Usage Tracking
+
+If you would prefer to send us raw usage manually (without wrappers) and have us compute the cost, you can attach usage data in the following format:
+
+```typescript
+import { PaidClient, Paid } from "@paid-ai/paid-node";
+
+const client = new PaidClient({ token: "<your_paid_api_key>" });
+
+const signal: Paid.Signal = {
+    event_name: "<your_signal_name>",
+    agent_id: "<your_agent_id>",
+    customer_id: "<your_external_customer_id>",
+    data: {
+        costData: {
+            vendor: "<any_vendor_name>", // can be anything, traces are grouped by vendors in the UI
+            attributes: {
+                "gen_ai.response.model": "gpt-4-turbo",
+                "gen_ai.usage.input_tokens": 100,
+                "gen_ai.usage.output_tokens": 300,
+                "gen_ai.usage.cached_input_tokens": 600,
+            },
+        }
+    }
+};
+
+await client.usage.recordBulk({ signals: [signal] });
+await client.usage.flush();
+```
+
+Same but via OTEL signaling:
+
+```typescript
+import { PaidClient } from "@paid-ai/paid-node";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+    await client.initializeTracing();
+
+    await client.trace("<your_external_customer_id>", async () => {
+        // ...do some work...
+        client.signal("<your_signal_name>", {
+            costData: {
+                vendor: "<any_vendor_name>", // can be anything, traces are grouped by vendors in the UI
+                attributes: {
+                    "gen_ai.response.model": "gpt-4-turbo",
+                    "gen_ai.usage.input_tokens": 100,
+                    "gen_ai.usage.output_tokens": 300,
+                    "gen_ai.usage.cached_input_tokens": 600,
+                },
+            }
+        });
+    }, "<your_external_agent_id>");
+}
+```
+
 ## Advanced
 
 ### Additional Headers

package/dist/cjs/Client.d.ts

@@ -41,4 +41,26 @@ export declare class PaidClient {
     get contacts(): Contacts;
     get orders(): Orders;
     get usage(): Usage;
+    initializeTracing(collectorEndpoint?: string): Promise<void>;
+    trace<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, externalAgentId?: string, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    /**
+     * Sends Paid signal. Needs to be called as part of callback to Paid.trace().
+     * When enableCostTracing flag is on, signal is associated
+     * with cost traces from the same Paid.trace() context.
+     *
+     * @param eventName - The name of the signal.
+     * @param enableCostTracing - Whether to associate this signal with cost traces
+     * from the current Paid.trace() context (default: false)
+     * @param data - Optional additional data to include with the signal
+     *
+     * @remarks
+     * When enableCostTracing is on, the signal will be associated with cost
+     * traces within the same Paid.trace() context.
+     * It is advised to only make one call to this function
+     * with enableCostTracing per Paid.trace() context.
+     * Otherwise, there will be multiple signals that refer to the same costs.
+     */
+    signal(eventName: string): void;
+    signal(eventName: string, data: Record<string, any>): void;
+    signal(eventName: string, enableCostTracing: boolean, data?: Record<string, any>): void;
 }

package/dist/cjs/Client.js

@@ -35,6 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+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.PaidClient = void 0;
 const core = __importStar(require("./core/index.js"));
@@ -44,13 +53,15 @@ const Client_js_2 = require("./api/resources/agents/client/Client.js");
 const Client_js_3 = require("./api/resources/contacts/client/Client.js");
 const Client_js_4 = require("./api/resources/orders/client/Client.js");
 const BatchUsage_js_1 = require("./wrapper/BatchUsage.js");
+const tracing_js_1 = require("./tracing/tracing.js");
+const signal_js_1 = require("./tracing/signal.js");
 class PaidClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: (0, headers_js_1.mergeHeaders)({
                 "X-Fern-Language": "JavaScript",
                 "X-Fern-SDK-Name": "@paid-ai/paid-node",
-                "X-Fern-SDK-Version": "0.0.6",
-                "User-Agent": "@paid-ai/paid-node/0.0.6",
+                "X-Fern-SDK-Version": "0.2.1",
+                "User-Agent": "@paid-ai/paid-node/0.2.1",
                 "X-Fern-Runtime": core.RUNTIME.type,
                 "X-Fern-Runtime-Version": core.RUNTIME.version,
             }, _options === null || _options === void 0 ? void 0 : _options.headers) });
@@ -75,5 +86,37 @@ class PaidClient {
         var _a;
         return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new BatchUsage_js_1.Usage(this._options)));
     }
+    // Need to call this method before using tracing or creating wrappers.
+    initializeTracing(collectorEndpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenSupplier = this._options.token;
+            const token = typeof tokenSupplier === "function" ? yield tokenSupplier() : tokenSupplier;
+            const resolvedToken = yield Promise.resolve(token);
+            (0, tracing_js_1._initializeTracing)(resolvedToken, collectorEndpoint);
+        });
+    }
+    // Use this method to track actions like LLM costs and sending signals.
+    // The callback to this function is the work that you want to trace.
+    trace(externalCustomerId, fn, externalAgentId, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, tracing_js_1._trace)(externalCustomerId, fn, externalAgentId, ...args);
+        });
+    }
+    signal(eventName, enableCostTracingOrData, data) {
+        let enableCostTracing = false;
+        let finalData;
+        if (typeof enableCostTracingOrData === 'boolean') {
+            // Case: signal(eventName, boolean, data?)
+            enableCostTracing = enableCostTracingOrData;
+            finalData = data;
+        }
+        else if (typeof enableCostTracingOrData === 'object') {
+            // Case: signal(eventName, data)
+            enableCostTracing = false;
+            finalData = enableCostTracingOrData;
+        }
+        // Case: signal(eventName) - both remain default/undefined
+        return (0, signal_js_1._signal)(eventName, enableCostTracing, finalData);
+    }
 }
 exports.PaidClient = PaidClient;

package/dist/cjs/anthropic-wrapper/index.d.ts

@@ -0,0 +1 @@
+export { PaidAnthropic } from "../tracing/wrappers/anthropicWrapper.js";

package/dist/cjs/anthropic-wrapper/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaidAnthropic = void 0;
+var anthropicWrapper_js_1 = require("../tracing/wrappers/anthropicWrapper.js");
+Object.defineProperty(exports, "PaidAnthropic", { enumerable: true, get: function () { return anthropicWrapper_js_1.PaidAnthropic; } });

package/dist/cjs/api/resources/agents/client/Client.d.ts

@@ -41,8 +41,9 @@ export declare class Agents {
      *
      * @example
      *     await client.agents.create({
-     *         name: "name",
-     *         description: "description"
+     *         name: "Acme Agent",
+     *         description: "Acme Agent is an AI agent that does things.",
+     *         externalId: "acme-agent"
      *     })
      */
     create(request: Paid.AgentCreate, requestOptions?: Agents.RequestOptions): core.HttpResponsePromise<Paid.Agent>;
@@ -62,7 +63,36 @@ export declare class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.update("agentId", {})
+     *     await client.agents.update("agentId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             tiers: [{
+     *                                     minQuantity: 0,
+     *                                     maxQuantity: 10,
+     *                                     unitPrice: 100
+     *                                 }, {
+     *                                     minQuantity: 11,
+     *                                     maxQuantity: 100,
+     *                                     unitPrice: 90
+     *                                 }, {
+     *                                     minQuantity: 101,
+     *                                     unitPrice: 80
+     *                                 }]
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     update(agentId: string, request: Paid.AgentUpdate, requestOptions?: Agents.RequestOptions): core.HttpResponsePromise<Paid.Agent>;
     private __update;
@@ -90,7 +120,25 @@ export declare class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.updateByExternalId("externalId", {})
+     *     await client.agents.updateByExternalId("externalId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             unitPrice: 150
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     updateByExternalId(externalId: string, request: Paid.AgentUpdate, requestOptions?: Agents.RequestOptions): core.HttpResponsePromise<Paid.Agent>;
     private __updateByExternalId;

package/dist/cjs/api/resources/agents/client/Client.js

@@ -111,8 +111,9 @@ class Agents {
      *
      * @example
      *     await client.agents.create({
-     *         name: "name",
-     *         description: "description"
+     *         name: "Acme Agent",
+     *         description: "Acme Agent is an AI agent that does things.",
+     *         externalId: "acme-agent"
      *     })
      */
     create(request, requestOptions) {
@@ -213,7 +214,36 @@ class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.update("agentId", {})
+     *     await client.agents.update("agentId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             tiers: [{
+     *                                     minQuantity: 0,
+     *                                     maxQuantity: 10,
+     *                                     unitPrice: 100
+     *                                 }, {
+     *                                     minQuantity: 11,
+     *                                     maxQuantity: 100,
+     *                                     unitPrice: 90
+     *                                 }, {
+     *                                     minQuantity: 101,
+     *                                     unitPrice: 80
+     *                                 }]
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     update(agentId, request, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__update(agentId, request, requestOptions));
@@ -361,7 +391,25 @@ class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.updateByExternalId("externalId", {})
+     *     await client.agents.updateByExternalId("externalId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             unitPrice: 150
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     updateByExternalId(externalId, request, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__updateByExternalId(externalId, request, requestOptions));

package/dist/cjs/api/resources/agents/client/requests/AgentCreate.d.ts

@@ -4,8 +4,9 @@
 /**
  * @example
  *     {
- *         name: "name",
- *         description: "description"
+ *         name: "Acme Agent",
+ *         description: "Acme Agent is an AI agent that does things.",
+ *         externalId: "acme-agent"
  *     }
  */
 export interface AgentCreate {
@@ -13,4 +14,5 @@ export interface AgentCreate {
     description: string;
     agentCode?: string;
     externalId?: string;
+    active?: boolean;
 }

package/dist/cjs/api/resources/contacts/client/Client.d.ts

@@ -41,14 +41,11 @@ export declare class Contacts {
      *
      * @example
      *     await client.contacts.create({
+     *         customerExternalId: "acme-inc",
      *         salutation: "Mr.",
-     *         firstName: "firstName",
-     *         lastName: "lastName",
-     *         email: "email",
-     *         billingStreet: "billingStreet",
-     *         billingCity: "billingCity",
-     *         billingCountry: "billingCountry",
-     *         billingPostalCode: "billingPostalCode"
+     *         firstName: "John",
+     *         lastName: "Doe",
+     *         email: "john.doe@example.com"
      *     })
      */
     create(request: Paid.ContactCreate, requestOptions?: Contacts.RequestOptions): core.HttpResponsePromise<Paid.Contact>;

package/dist/cjs/api/resources/contacts/client/Client.js

@@ -111,14 +111,11 @@ class Contacts {
      *
      * @example
      *     await client.contacts.create({
+     *         customerExternalId: "acme-inc",
      *         salutation: "Mr.",
-     *         firstName: "firstName",
-     *         lastName: "lastName",
-     *         email: "email",
-     *         billingStreet: "billingStreet",
-     *         billingCity: "billingCity",
-     *         billingCountry: "billingCountry",
-     *         billingPostalCode: "billingPostalCode"
+     *         firstName: "John",
+     *         lastName: "Doe",
+     *         email: "john.doe@example.com"
      *     })
      */
     create(request, requestOptions) {

package/dist/cjs/api/resources/contacts/client/requests/ContactCreate.d.ts

@@ -5,14 +5,11 @@ import * as Paid from "../../../../index.js";
 /**
  * @example
  *     {
+ *         customerExternalId: "acme-inc",
  *         salutation: "Mr.",
- *         firstName: "firstName",
- *         lastName: "lastName",
- *         email: "email",
- *         billingStreet: "billingStreet",
- *         billingCity: "billingCity",
- *         billingCountry: "billingCountry",
- *         billingPostalCode: "billingPostalCode"
+ *         firstName: "John",
+ *         lastName: "Doe",
+ *         email: "john.doe@example.com"
  *     }
  */
 export interface ContactCreate {
@@ -24,9 +21,9 @@ export interface ContactCreate {
     lastName: string;
     email: string;
     phone?: string;
-    billingStreet: string;
-    billingCity: string;
+    billingStreet?: string;
+    billingCity?: string;
     billingStateProvince?: string;
-    billingCountry: string;
-    billingPostalCode: string;
+    billingCountry?: string;
+    billingPostalCode?: string;
 }