@vigneshreddy/cms-sdk 1.0.8 → 1.0.10

package/README.md

@@ -3,8 +3,8 @@
 Official TypeScript/JavaScript SDK for the CutMeShort CMS API.
 
 Use this package to send:
-- lead tracking events (`trackLead`)
-- sale tracking events (`trackSale`)
+- lead tracking events (`cms.trackLead`)
+- sale tracking events (`cms.trackSale`)
 
 ## Install
 
@@ -49,7 +49,7 @@ console.log(response);
 
 ## API Methods
 
-### `trackLead(leadData, options?)`
+### `cms.trackLead(leadData, options?)`
 
 ```ts
 import { CMS } from "@vigneshreddy/cms-sdk";
@@ -64,79 +64,68 @@ await cms.trackLead({
 ```
 
 Lead payload fields:
-- `clickId: string`
+- `clickId: string` (optional in **deferred** follow-up calls)
 - `eventName: string`
 - `customerId: string`
+- `timestamp?: string` (ISO 8601, e.g. `new Date().toISOString()`)
+- `customerExternalId?: string`
+- `customerName?: string`
+- `customerEmail?: string`
+- `customerAvatar?: string`
 
-### `trackSale(saleData, options?)`
-
-```ts
-import { CMS } from "@vigneshreddy/cms-sdk";
-
-const cms = new CMS({ apiKey: "sk_live_xxx" });
-
-await cms.trackSale({
-  clickId: "id_123",
-  eventName: "purchase_completed",
-  invoiceId: "inv_987",
-  amount: 4999,
-  currency: "USD",
-});
-```
-
-Sale payload fields:
-- `clickId: string`
-- `eventName: string`
-- `invoiceId: string`
-- `amount: number` (in cents)
-- `currency: string` (3-letter code, e.g. `USD`)
-
-## Functional Style (Result Pattern)
-
-If you prefer not to use `try/catch`, use helper functions that return `Result`.
+#### Deferred mode (two-step lead attribution)
 
-### Lead Example
+If you can’t reliably send the `clickId` at the moment you want to record a lead event, you can use **deferred mode**:
 
 ```ts
-import { CMS, trackLead } from "@vigneshreddy/cms-sdk";
+import { CMS } from "@vigneshreddy/cms-sdk";
 
 const cms = new CMS({ apiKey: "sk_live_xxx" });
 
-const result = await trackLead(cms, {
+// Step 1: store the clickId <-> customerId association
+await cms.trackLead({
   clickId: "id_123",
   eventName: "signup_started",
   customerId: "user_42",
+  mode: "deferred",
 });
 
-if (result.ok) {
-  console.log("Tracked lead:", result.value);
-} else {
-  console.error("Lead error:", result.error);
-}
+// Step 2: later, track using just customerId (no clickId)
+await cms.trackLead({
+  eventName: "email_verified",
+  customerId: "user_42",
+  mode: "deferred",
+});
 ```
 
-### Sale Example
+### `cms.trackSale(saleData, options?)`
 
 ```ts
-import { CMS, trackSale } from "@vigneshreddy/cms-sdk";
+import { CMS } from "@vigneshreddy/cms-sdk";
 
 const cms = new CMS({ apiKey: "sk_live_xxx" });
 
-const result = await trackSale(cms, {
+await cms.trackSale({
   clickId: "id_123",
   eventName: "purchase_completed",
   invoiceId: "inv_987",
   amount: 4999,
   currency: "USD",
 });
-
-if (result.ok) {
-  console.log("Tracked sale:", result.value);
-} else {
-  console.error("Sale error:", result.error);
-}
 ```
 
+Sale payload fields:
+- `clickId: string`
+- `eventName: string`
+- `timestamp?: string` (ISO 8601, e.g. `new Date().toISOString()`)
+- `customerExternalId?: string`
+- `customerName?: string`
+- `customerEmail?: string`
+- `customerAvatar?: string`
+- `invoiceId: string`
+- `amount: number` (in cents)
+- `currency: string` (3-letter code, e.g. `USD`)
+
 ## Configuration
 
 `new CMS(config)` accepts:
@@ -144,18 +133,22 @@ if (result.ok) {
 ```ts
 type CMSConfig = {
   apiKey: string;
+  baseUrl?: string;
   timeout?: number;
   maxRetries?: number;
   retryDelayMs?: number;
+  retryMaxDelayMs?: number;
   retryOnStatuses?: number[];
   retryOnNetworkError?: boolean;
 };
 ```
 
 Defaults:
+- `baseUrl`: `https://www.cutmeshort.com/sdk`
 - `timeout`: `10000`
 - `maxRetries`: `2`
 - `retryDelayMs`: `500`
+- `retryMaxDelayMs`: `10000`
 - `retryOnStatuses`: `[429, 500, 502, 503, 504]`
 - `retryOnNetworkError`: `true`
 
@@ -212,26 +205,13 @@ try {
 }
 ```
 
-## TypeScript Types
-
-```ts
-import type {
-  TrackLeadRequest,
-  TrackSaleRequest,
-  TrackResponse,
-  RequestOptions,
-  CMSConfig,
-} from "@vigneshreddy/cms-sdk";
-```
+## Public API
 
-## Exports
+This package intentionally exposes only:
+- `CMS` (use `cms.trackLead` and `cms.trackSale`)
+- `CMSAPIError` (for `instanceof` checks)
 
-Main package exports:
-- `CMS`
-- `trackLead`, `trackSale`
-- `CMSAPIError` and specific error classes
-- `ok`, `err`, `Result`
-- generated request/response types
+Deep imports (example: `@vigneshreddy/cms-sdk/client`) are intentionally blocked.
 
 ## Security Best Practice
 

package/dist/src/client.d.ts

@@ -1,8 +1,10 @@
-import { EventsApi } from "./generated";
-export type LeadPayload = Record<string, unknown>;
-export type SalePayload = Record<string, unknown>;
+import { EventsApi, TrackLeadRequest, TrackSaleRequest } from "./generated";
+export type LeadPayload = TrackLeadRequest;
+export type SalePayload = TrackSaleRequest;
 export interface CMSConfig {
     apiKey: string;
+    /** Base URL for the CMS API */
+    baseUrl?: string;
     /**
      * Optional timeout in milliseconds for HTTP requests.
      * This is implemented using AbortController around the native fetch API.
@@ -12,6 +14,8 @@ export interface CMSConfig {
     maxRetries?: number;
     /** Base delay (in ms) between retries for transient failures */
     retryDelayMs?: number;
+    /** Maximum delay cap (in ms) for retry backoff */
+    retryMaxDelayMs?: number;
     /** HTTP status codes that should be retried */
     retryOnStatuses?: number[];
     /** Whether to retry on network errors (no response / timeout) */
@@ -27,6 +31,8 @@ export interface RequestOptions {
     maxRetries?: number;
     /** Override retry delay for this specific request */
     retryDelayMs?: number;
+    /** Override retry max delay for this specific request */
+    retryMaxDelayMs?: number;
     /** Override retry status codes for this specific request */
     retryOnStatuses?: number[];
     /** Override retry on network error setting for this specific request */
@@ -36,11 +42,19 @@ export declare class CMS {
     readonly events: EventsApi;
     private readonly maxRetries;
     private readonly retryDelayMs;
+    private readonly retryMaxDelayMs;
     private readonly retryOnStatuses;
     private readonly retryOnNetworkError;
     constructor(config: CMSConfig);
-    private isRetryableError;
     private sleep;
+    private normalizeBaseUrl;
+    private resolveNonNegativeInt;
+    private resolvePositiveInt;
+    private resolveRetryStatuses;
+    private getHeaderValue;
+    private parseRetryAfterMs;
+    private getRetryDelayMs;
+    private toGeneratedRequestOptions;
     private withRetry;
     private isRetryableErrorWithOptions;
     trackLead(leadData: LeadPayload, options?: RequestOptions): Promise<import("./generated").TrackResponse>;

package/dist/src/client.js

@@ -4,27 +4,32 @@ exports.CMS = void 0;
 // src/client.ts
 const generated_1 = require("./generated");
 const errors_1 = require("./errors");
+const DEFAULT_BASE_URL = "https://www.cutmeshort.com";
+const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_RETRY_DELAY_MS = 500;
+const DEFAULT_RETRY_MAX_DELAY_MS = 10000;
+const DEFAULT_RETRY_STATUSES = [429, 500, 502, 503, 504];
 class CMS {
     constructor(config) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         if (!config.apiKey) {
             throw new Error("CMS SDK: apiKey is required.");
         }
-        // Absolute base URL for the CMS SDK – we intentionally do NOT append
-        // per-endpoint paths like /track/lead; callers just hit this base.
-        const basePath = "http://localhost:5000/sdk";
+        const basePath = this.normalizeBaseUrl((_a = config.baseUrl) !== null && _a !== void 0 ? _a : DEFAULT_BASE_URL);
         // Retry configuration with sensible defaults
-        this.maxRetries = (_a = config.maxRetries) !== null && _a !== void 0 ? _a : 2;
-        this.retryDelayMs = (_b = config.retryDelayMs) !== null && _b !== void 0 ? _b : 500;
-        this.retryOnStatuses = new Set((_c = config.retryOnStatuses) !== null && _c !== void 0 ? _c : [429, 500, 502, 503, 504]);
-        this.retryOnNetworkError = (_d = config.retryOnNetworkError) !== null && _d !== void 0 ? _d : true;
+        this.maxRetries = this.resolveNonNegativeInt(config.maxRetries, DEFAULT_MAX_RETRIES, "maxRetries");
+        this.retryDelayMs = this.resolvePositiveInt(config.retryDelayMs, DEFAULT_RETRY_DELAY_MS, "retryDelayMs");
+        this.retryMaxDelayMs = this.resolvePositiveInt(config.retryMaxDelayMs, DEFAULT_RETRY_MAX_DELAY_MS, "retryMaxDelayMs");
+        this.retryOnStatuses = this.resolveRetryStatuses((_b = config.retryOnStatuses) !== null && _b !== void 0 ? _b : DEFAULT_RETRY_STATUSES);
+        this.retryOnNetworkError = (_c = config.retryOnNetworkError) !== null && _c !== void 0 ? _c : true;
         // Create the Configuration object
         const apiConfig = new generated_1.Configuration({
             basePath,
             accessToken: config.apiKey,
             baseOptions: {
                 // Ensure generated client uses the same timeout & headers
-                timeout: (_e = config.timeout) !== null && _e !== void 0 ? _e : 10000,
+                timeout: (_d = config.timeout) !== null && _d !== void 0 ? _d : DEFAULT_TIMEOUT_MS,
                 headers: {
                     'Content-Type': 'application/json'
                 },
@@ -34,33 +39,113 @@ class CMS {
         // The underlying implementation uses the global `fetch` API.
         this.events = new generated_1.EventsApi(apiConfig, basePath);
     }
-    isRetryableError(error) {
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    normalizeBaseUrl(baseUrl) {
+        try {
+            const parsed = new URL(baseUrl);
+            return parsed.toString().replace(/\/+$/, "");
+        }
+        catch {
+            throw new Error("CMS SDK: baseUrl must be a valid absolute URL.");
+        }
+    }
+    resolveNonNegativeInt(value, fallback, key) {
+        if (typeof value === "undefined") {
+            return fallback;
+        }
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`CMS SDK: ${key} must be a non-negative integer.`);
+        }
+        return value;
+    }
+    resolvePositiveInt(value, fallback, key) {
+        if (typeof value === "undefined") {
+            return fallback;
+        }
+        if (!Number.isInteger(value) || value <= 0) {
+            throw new Error(`CMS SDK: ${key} must be a positive integer.`);
+        }
+        return value;
+    }
+    resolveRetryStatuses(statuses) {
+        const invalid = statuses.find((status) => !Number.isInteger(status) || status < 100 || status > 599);
+        if (typeof invalid !== "undefined") {
+            throw new Error("CMS SDK: retryOnStatuses must contain valid HTTP status codes.");
+        }
+        return new Set(statuses);
+    }
+    getHeaderValue(headers, headerName) {
         var _a;
-        const axiosError = error;
-        // Network / timeout errors
-        if (this.retryOnNetworkError && (!axiosError.response || axiosError.code === "ECONNABORTED")) {
-            return true;
+        if (!headers) {
+            return undefined;
         }
-        // HTTP status based retries
-        const status = (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.status;
-        if (status && this.retryOnStatuses.has(status)) {
-            return true;
+        const normalizedName = headerName.toLowerCase();
+        if (headers instanceof Headers) {
+            return (_a = headers.get(headerName)) !== null && _a !== void 0 ? _a : undefined;
         }
-        return false;
+        if (Array.isArray(headers)) {
+            const match = headers.find(([key]) => String(key).toLowerCase() === normalizedName);
+            return match ? String(match[1]) : undefined;
+        }
+        if (typeof headers === "object") {
+            const entries = Object.entries(headers);
+            const match = entries.find(([key]) => key.toLowerCase() === normalizedName);
+            return match ? String(match[1]) : undefined;
+        }
+        return undefined;
     }
-    async sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+    parseRetryAfterMs(value) {
+        if (!value) {
+            return undefined;
+        }
+        const seconds = Number(value);
+        if (Number.isFinite(seconds) && seconds >= 0) {
+            return Math.floor(seconds * 1000);
+        }
+        const timestamp = Date.parse(value);
+        if (Number.isFinite(timestamp)) {
+            const diff = timestamp - Date.now();
+            if (diff > 0) {
+                return Math.floor(diff);
+            }
+        }
+        return undefined;
+    }
+    getRetryDelayMs(error, attempt, retryDelayMs, retryMaxDelayMs) {
+        var _a;
+        const responseHeaders = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.headers;
+        const retryAfterHeader = this.getHeaderValue(responseHeaders, "retry-after");
+        const retryAfterMs = this.parseRetryAfterMs(retryAfterHeader);
+        if (typeof retryAfterMs === "number") {
+            return Math.min(retryAfterMs, retryMaxDelayMs);
+        }
+        const exponentialBase = Math.min(retryDelayMs * Math.pow(2, Math.max(0, attempt - 1)), retryMaxDelayMs);
+        const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(exponentialBase * 0.25)));
+        return Math.min(exponentialBase + jitter, retryMaxDelayMs);
+    }
+    toGeneratedRequestOptions(options) {
+        if (!options) {
+            return undefined;
+        }
+        const requestOptions = {};
+        if (typeof options.timeout === "number") {
+            requestOptions.timeout = options.timeout;
+        }
+        return requestOptions;
     }
     async withRetry(fn, options) {
-        var _a, _b, _c;
+        var _a;
         let attempt = 0;
         // Use per-request options if provided, otherwise use instance defaults
-        const maxRetries = (_a = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _a !== void 0 ? _a : this.maxRetries;
-        const retryDelayMs = (_b = options === null || options === void 0 ? void 0 : options.retryDelayMs) !== null && _b !== void 0 ? _b : this.retryDelayMs;
+        const maxRetries = this.resolveNonNegativeInt(options === null || options === void 0 ? void 0 : options.maxRetries, this.maxRetries, "maxRetries");
+        const retryDelayMs = this.resolvePositiveInt(options === null || options === void 0 ? void 0 : options.retryDelayMs, this.retryDelayMs, "retryDelayMs");
+        const retryMaxDelayMs = this.resolvePositiveInt(options === null || options === void 0 ? void 0 : options.retryMaxDelayMs, this.retryMaxDelayMs, "retryMaxDelayMs");
         const retryOnStatuses = (options === null || options === void 0 ? void 0 : options.retryOnStatuses)
-            ? new Set(options.retryOnStatuses)
+            ? this.resolveRetryStatuses(options.retryOnStatuses)
             : this.retryOnStatuses;
-        const retryOnNetworkError = (_c = options === null || options === void 0 ? void 0 : options.retryOnNetworkError) !== null && _c !== void 0 ? _c : this.retryOnNetworkError;
+        const retryOnNetworkError = (_a = options === null || options === void 0 ? void 0 : options.retryOnNetworkError) !== null && _a !== void 0 ? _a : this.retryOnNetworkError;
         // attempt 0 + maxRetries additional retries
         // e.g. maxRetries=2 -> attempts: 0,1,2
         const maxAttempts = maxRetries + 1;
@@ -77,7 +162,7 @@ class CMS {
                     // Final failure, let our error handler wrap it
                     return (0, errors_1.handleApiError)(error);
                 }
-                const delay = retryDelayMs * attempt; // simple linear backoff
+                const delay = this.getRetryDelayMs(error, attempt, retryDelayMs, retryMaxDelayMs);
                 await this.sleep(delay);
             }
         }
@@ -97,21 +182,15 @@ class CMS {
         return false;
     }
     async trackLead(leadData, options) {
-        const payload = {
-            type: "lead",
-            lead: leadData,
-        };
+        const requestOptions = this.toGeneratedRequestOptions(options);
         return this.withRetry(async () => {
-            return this.events.trackLead(payload);
+            return this.events.trackLead(leadData, requestOptions);
         }, options);
     }
     async trackSale(saleData, options) {
-        const payload = {
-            type: "sale",
-            sale: saleData,
-        };
+        const requestOptions = this.toGeneratedRequestOptions(options);
         return this.withRetry(async () => {
-            return this.events.trackSale(payload);
+            return this.events.trackSale(saleData, requestOptions);
         }, options);
     }
 }

package/dist/src/errors/base.d.ts

@@ -6,12 +6,14 @@ export declare class CMSAPIError extends Error {
     readonly statusCode: number;
     readonly type: string;
     readonly rawError: any;
-    readonly request?: {
+    readonly cause?: unknown;
+    request?: {
         url?: string;
         method?: string;
         headers?: Record<string, any>;
+        timeout?: number;
     };
-    readonly response?: {
+    response?: {
         status: number;
         statusText: string;
         data?: any;

package/dist/src/errors/base.js

@@ -12,13 +12,20 @@ class CMSAPIError extends Error {
         this.statusCode = statusCode;
         this.type = type;
         this.rawError = rawError;
+        this.cause = rawError;
         this.request = request;
         this.response = response;
+        // Ensure proper prototype chain in transpiled output
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (typeof Error.captureStackTrace === "function") {
+            Error.captureStackTrace(this, new.target);
+        }
         // Make heavy properties non-enumerable so console.log / inspection
         // stays focused on the high-level error information.
         try {
             Object.defineProperties(this, {
                 rawError: { enumerable: false },
+                cause: { enumerable: false },
                 request: { enumerable: false },
                 response: { enumerable: false },
             });

package/dist/src/errors/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSpecificError = exports.GatewayTimeoutError = exports.ServiceUnavailableError = exports.BadGatewayError = exports.InternalServerError = exports.RateLimitError = exports.UnprocessableEntityError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.handleApiError = exports.CMSAPIError = void 0;
-// Re-export base error
+// Re-export base error and handler for convenience
 var base_1 = require("./base");
 Object.defineProperty(exports, "CMSAPIError", { enumerable: true, get: function () { return base_1.CMSAPIError; } });
 var errors_1 = require("../errors");

package/dist/src/errors.d.ts

@@ -1,8 +1,8 @@
 import { CMSAPIError } from "./errors/base";
 export { CMSAPIError };
-export { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, BadGatewayError, ServiceUnavailableError, GatewayTimeoutError, createSpecificError, } from "./errors/index";
+export { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, BadGatewayError, ServiceUnavailableError, GatewayTimeoutError, createSpecificError, } from "./errors/specific";
 /**
- * Parses fetch/network errors into a clean CMSAPIError
+ * Parses fetch/network errors into a clean CMSAPIError (or specific subclass)
  * Uses specific error types when possible for better type safety
  */
-export declare function handleApiError(error: any, request?: any, response?: any): never;
+export declare function handleApiError(error: unknown, request?: unknown, response?: unknown): never;

package/dist/src/errors.js

@@ -5,64 +5,74 @@ exports.handleApiError = handleApiError;
 // src/errors.ts
 const base_1 = require("./errors/base");
 Object.defineProperty(exports, "CMSAPIError", { enumerable: true, get: function () { return base_1.CMSAPIError; } });
+const specific_1 = require("./errors/specific");
 // Re-export specific error types
-var index_1 = require("./errors/index");
-Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return index_1.BadRequestError; } });
-Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return index_1.UnauthorizedError; } });
-Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return index_1.ForbiddenError; } });
-Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return index_1.NotFoundError; } });
-Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return index_1.ConflictError; } });
-Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, get: function () { return index_1.UnprocessableEntityError; } });
-Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return index_1.RateLimitError; } });
-Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return index_1.InternalServerError; } });
-Object.defineProperty(exports, "BadGatewayError", { enumerable: true, get: function () { return index_1.BadGatewayError; } });
-Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return index_1.ServiceUnavailableError; } });
-Object.defineProperty(exports, "GatewayTimeoutError", { enumerable: true, get: function () { return index_1.GatewayTimeoutError; } });
-Object.defineProperty(exports, "createSpecificError", { enumerable: true, get: function () { return index_1.createSpecificError; } });
+var specific_2 = require("./errors/specific");
+Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return specific_2.BadRequestError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return specific_2.UnauthorizedError; } });
+Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return specific_2.ForbiddenError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return specific_2.NotFoundError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return specific_2.ConflictError; } });
+Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, get: function () { return specific_2.UnprocessableEntityError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return specific_2.RateLimitError; } });
+Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return specific_2.InternalServerError; } });
+Object.defineProperty(exports, "BadGatewayError", { enumerable: true, get: function () { return specific_2.BadGatewayError; } });
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return specific_2.ServiceUnavailableError; } });
+Object.defineProperty(exports, "GatewayTimeoutError", { enumerable: true, get: function () { return specific_2.GatewayTimeoutError; } });
+Object.defineProperty(exports, "createSpecificError", { enumerable: true, get: function () { return specific_2.createSpecificError; } });
 /**
- * Parses fetch/network errors into a clean CMSAPIError
+ * Parses fetch/network errors into a clean CMSAPIError (or specific subclass)
  * Uses specific error types when possible for better type safety
  */
 function handleApiError(error, request, response) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (error instanceof base_1.CMSAPIError) {
+        throw error; // preserve original error metadata/type
+    }
     const sanitizeRequest = (req) => {
         if (!req || typeof req !== "object")
             return undefined;
+        const r = req;
         return {
-            url: req.url,
-            method: req.method,
+            url: typeof r.url === "string" ? r.url : undefined,
+            method: typeof r.method === "string" ? r.method : undefined,
+            timeout: typeof r.timeout === "number" ? r.timeout : undefined,
+            headers: typeof r.headers === "object" && r.headers !== null
+                ? r.headers
+                : undefined,
         };
     };
     // Error with response from server
-    if ((error === null || error === void 0 ? void 0 : error.response) || response) {
-        const res = (error === null || error === void 0 ? void 0 : error.response) || response;
-        const statusCode = res.status || res.statusCode || 500;
-        const message = ((_a = res.data) === null || _a === void 0 ? void 0 : _a.message) ||
-            res.statusText ||
-            "Unknown API Error";
-        // Create error with request/response metadata
-        const apiError = new base_1.CMSAPIError(`CMS API Error: ${statusCode} - ${message}`, statusCode, ((_b = res.data) === null || _b === void 0 ? void 0 : _b.type) || "api_error", (_c = res.data) !== null && _c !== void 0 ? _c : error, sanitizeRequest(request || (error === null || error === void 0 ? void 0 : error.request)), {
+    const errorWithResponse = (_a = error === null || error === void 0 ? void 0 : error.response) !== null && _a !== void 0 ? _a : response;
+    if (errorWithResponse) {
+        const res = errorWithResponse;
+        const statusCode = (_c = (_b = res.status) !== null && _b !== void 0 ? _b : res.statusCode) !== null && _c !== void 0 ? _c : 500;
+        const message = (_f = (_e = (_d = res.data) === null || _d === void 0 ? void 0 : _d.message) !== null && _e !== void 0 ? _e : res.statusText) !== null && _f !== void 0 ? _f : "Unknown API Error";
+        // Prefer typed error subclasses when possible
+        const typedError = (0, specific_1.createSpecificError)(statusCode, `CMS API Error: ${statusCode} - ${message}`, (_g = res.data) !== null && _g !== void 0 ? _g : error);
+        typedError.request = sanitizeRequest(request !== null && request !== void 0 ? request : error === null || error === void 0 ? void 0 : error.request);
+        typedError.response = {
             status: statusCode,
             statusText: res.statusText || "",
             data: res.data,
             headers: res.headers,
-        });
-        throw apiError;
+        };
+        throw typedError;
     }
     // Error where request was made but no response received
-    if ((error === null || error === void 0 ? void 0 : error.request) || request) {
-        const req = sanitizeRequest((error === null || error === void 0 ? void 0 : error.request) || request);
-        const isTimeout = error.code === "ECONNABORTED" ||
-            typeof error.message === "string" &&
-                error.message.toLowerCase().includes("timeout");
+    const errorWithRequest = (_h = error === null || error === void 0 ? void 0 : error.request) !== null && _h !== void 0 ? _h : request;
+    if (errorWithRequest) {
+        const req = sanitizeRequest(errorWithRequest);
+        const isTimeout = (error === null || error === void 0 ? void 0 : error.code) === "ECONNABORTED" ||
+            (typeof (error === null || error === void 0 ? void 0 : error.message) === "string" &&
+                error.message.toLowerCase().includes("timeout"));
         if (isTimeout) {
             throw new base_1.CMSAPIError("Timeout Error: CMS API did not respond in time.", 0, "timeout_error", error, req);
         }
         throw new base_1.CMSAPIError("Network Error: No response received from CMS API. Please check your internet connection.", 0, "network_error", error, req);
     }
     // Fallback: unexpected or non-network error
-    const message = (error === null || error === void 0 ? void 0 : error.message) && typeof error.message === "string"
-        ? error.message
-        : "Unexpected client error while calling CMS API.";
+    const errMessage = typeof (error === null || error === void 0 ? void 0 : error.message) === "string" ? error.message : undefined;
+    const message = errMessage !== null && errMessage !== void 0 ? errMessage : "Unexpected client error while calling CMS API.";
     throw new base_1.CMSAPIError(`Client Error: ${message}`, -1, "client_error", error);
 }

package/dist/src/generated/api.d.ts

@@ -1,28 +1,74 @@
-/**
- * CMS API
- * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
- *
- * The version of the OpenAPI document: 1.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
 import type { Configuration } from './configuration';
 import type { RequestArgs, RequestOptions } from './base';
 import { BaseAPI } from './base';
-export interface TrackLeadRequest {
+export type TrackLeadRequest = {
     /**
-     * The `dub_id` from the cookie.
+     * The `cms_id` from the cookie.
      */
     'clickId': string;
     'eventName': string;
     /**
-     * Unique User ID. [cite_start]Used for deduplication (User cannot signup twice)[cite: 212].
+     * Unique User ID. Used for deduplication (user cannot signup twice).
      */
     'customerId': string;
-}
+    /**
+     * When set to `"deferred"`, the API may associate `clickId` to `customerId`
+     * for later attribution.
+     */
+    'mode'?: 'deferred';
+    /**
+     * Optional event timestamp in ISO 8601 format.
+     */
+    'timestamp'?: string;
+    /**
+     * Optional external customer identifier used in your system.
+     */
+    'customerExternalId'?: string;
+    /**
+     * Optional customer display name.
+     */
+    'customerName'?: string;
+    /**
+     * Optional customer email address.
+     */
+    'customerEmail'?: string;
+    /**
+     * Optional URL to a customer avatar image.
+     */
+    'customerAvatar'?: string;
+} | {
+    /**
+     * In deferred mode, a follow-up call can omit `clickId` and only provide
+     * `customerId` (and `eventName`) to attribute using the stored association.
+     */
+    'clickId'?: never;
+    'eventName': string;
+    /**
+     * Unique User ID. Used for deduplication (user cannot signup twice).
+     */
+    'customerId': string;
+    'mode': 'deferred';
+    /**
+     * Optional event timestamp in ISO 8601 format.
+     */
+    'timestamp'?: string;
+    /**
+     * Optional external customer identifier used in your system.
+     */
+    'customerExternalId'?: string;
+    /**
+     * Optional customer display name.
+     */
+    'customerName'?: string;
+    /**
+     * Optional customer email address.
+     */
+    'customerEmail'?: string;
+    /**
+     * Optional URL to a customer avatar image.
+     */
+    'customerAvatar'?: string;
+};
 export interface TrackResponse {
     'status'?: string;
 }
@@ -33,7 +79,27 @@ export interface TrackSaleRequest {
     'clickId': string;
     'eventName': string;
     /**
-     * Unique Transaction ID. [cite_start]Used for deduplication (Charge cannot happen twice)[cite: 214].
+     * Optional event timestamp in ISO 8601 format.
+     */
+    'timestamp'?: string;
+    /**
+     * Optional external customer identifier used in your system.
+     */
+    'customerExternalId'?: string;
+    /**
+     * Optional customer display name.
+     */
+    'customerName'?: string;
+    /**
+     * Optional customer email address.
+     */
+    'customerEmail'?: string;
+    /**
+     * Optional URL to a customer avatar image.
+     */
+    'customerAvatar'?: string;
+    /**
+     * Unique Transaction ID. Used for deduplication (charge cannot happen twice).
      */
     'invoiceId': string;
     /**

package/dist/src/generated/api.js

@@ -1,21 +1,6 @@
 "use strict";
-/* tslint:disable */
-/* eslint-disable */
-/**
- * CMS API
- * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
- *
- * The version of the OpenAPI document: 1.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventsApi = exports.EventsApiFactory = exports.EventsApiFp = exports.EventsApiAxiosParamCreator = void 0;
-// Some imports not used depending on template conditions
-// @ts-ignore
 const common_1 = require("./common");
 // @ts-ignore
 const base_1 = require("./base");
@@ -34,9 +19,7 @@ const EventsApiAxiosParamCreator = function (configuration) {
         trackLead: async (trackLeadRequest, options = {}) => {
             // verify required parameter 'trackLeadRequest' is not null or undefined
             (0, common_1.assertParamExists)('trackLead', 'trackLeadRequest', trackLeadRequest);
-            // We already include the full `/sdk` URL in the SDK's basePath,
-            // so we do not append any additional path segments here.
-            const localVarPath = ``;
+            const localVarPath = `/track/lead`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
             let baseOptions;
@@ -70,9 +53,7 @@ const EventsApiAxiosParamCreator = function (configuration) {
         trackSale: async (trackSaleRequest, options = {}) => {
             // verify required parameter 'trackSaleRequest' is not null or undefined
             (0, common_1.assertParamExists)('trackSale', 'trackSaleRequest', trackSaleRequest);
-            // We already include the full `/sdk` URL in the SDK's basePath,
-            // so we do not append any additional path segments here.
-            const localVarPath = ``;
+            const localVarPath = `/track/sale`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
             let baseOptions;
@@ -200,7 +181,6 @@ exports.EventsApi = EventsApi;
  * operate without changes.
  */
 async function performFetchRequest(requestArgs, basePath) {
-    var _a;
     const url = (basePath !== null && basePath !== void 0 ? basePath : base_1.BASE_PATH).replace(/\/+$/, "") + requestArgs.url;
     const { timeout, data, ...restOptions } = requestArgs.options;
     if (typeof fetch !== "function") {
@@ -217,10 +197,25 @@ async function performFetchRequest(requestArgs, basePath) {
         // The generated client stores the request payload on `data` (Axios-style),
         // but the fetch API expects it on `body`. Translate between the two.
         if (typeof data !== "undefined") {
-            const headers = ((_a = fetchOptions.headers) !== null && _a !== void 0 ? _a : {});
-            const requestContentType = Object.keys(headers).find((h) => h.toLowerCase() === "content-type");
+            const rawHeaders = fetchOptions.headers;
+            let headers = {};
+            if (rawHeaders instanceof Headers) {
+                rawHeaders.forEach((value, key) => {
+                    headers[key] = value;
+                });
+            }
+            else if (Array.isArray(rawHeaders)) {
+                headers = Object.fromEntries(rawHeaders.map(([key, value]) => [String(key), String(value)]));
+            }
+            else if (rawHeaders && typeof rawHeaders === "object") {
+                headers = Object.fromEntries(Object.entries(rawHeaders).map(([key, value]) => [key, String(value)]));
+            }
+            const requestContentTypeHeader = Object.keys(headers).find((h) => h.toLowerCase() === "content-type");
+            const requestContentType = requestContentTypeHeader
+                ? headers[requestContentTypeHeader]
+                : undefined;
             // If Content-Type is JSON (our default), ensure the body is a JSON string.
-            if (requestContentType && headers[requestContentType].includes("application/json")) {
+            if (requestContentType === null || requestContentType === void 0 ? void 0 : requestContentType.toLowerCase().includes("application/json")) {
                 fetchOptions.body =
                     typeof data === "string" ? data : JSON.stringify(data);
             }
@@ -231,13 +226,32 @@ async function performFetchRequest(requestArgs, basePath) {
         const response = await fetch(url, fetchOptions);
         const responseContentType = response.headers.get("content-type") || "";
         const isJson = responseContentType.toLowerCase().includes("application/json");
-        const dataResult = isJson ? await response.json() : await response.text();
+        let dataResult = null;
+        if (response.status !== 204 && response.status !== 205) {
+            const responseText = await response.text();
+            if (isJson && responseText) {
+                try {
+                    dataResult = JSON.parse(responseText);
+                }
+                catch {
+                    dataResult = responseText;
+                }
+            }
+            else {
+                dataResult = responseText;
+            }
+        }
         if (!response.ok) {
+            const responseHeaders = {};
+            response.headers.forEach((value, key) => {
+                responseHeaders[key] = value;
+            });
             const error = new Error(`Request failed with status code ${response.status}`);
             error.response = {
                 status: response.status,
                 statusText: response.statusText,
                 data: dataResult,
+                headers: responseHeaders,
             };
             throw error;
         }

package/dist/src/generated/base.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operationServerMap = exports.RequiredError = exports.BaseAPI = exports.COLLECTION_FORMATS = exports.BASE_PATH = void 0;
-exports.BASE_PATH = "https://www.cutmeshort.com/sdk".replace(/\/+$/, "");
+exports.BASE_PATH = "https://www.cutmeshort.com".replace(/\/+$/, "");
 exports.COLLECTION_FORMATS = {
     csv: ",",
     ssv: " ",

package/dist/src/index.d.ts

@@ -1,6 +1,2 @@
-export { CMS, type CMSConfig, type RequestOptions } from "./client";
-export { CMSAPIError, handleApiError } from "./errors";
-export * from "./errors/index";
-export { trackLead, trackSale, type TrackLeadError, type TrackSaleError } from "./funcs";
-export { ok, err, type Result } from "./types/result";
-export type { TrackLeadRequest, TrackSaleRequest, TrackResponse, } from "./generated/api";
+export { CMS } from "./client";
+export { CMSAPIError } from "./errors";

package/dist/src/index.js

@@ -1,34 +1,7 @@
 "use strict";
-// src/index.ts
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.err = exports.ok = exports.trackSale = exports.trackLead = exports.handleApiError = exports.CMSAPIError = exports.CMS = void 0;
-// Main client
+exports.CMSAPIError = exports.CMS = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "CMS", { enumerable: true, get: function () { return client_1.CMS; } });
-// Errors
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "CMSAPIError", { enumerable: true, get: function () { return errors_1.CMSAPIError; } });
-Object.defineProperty(exports, "handleApiError", { enumerable: true, get: function () { return errors_1.handleApiError; } });
-__exportStar(require("./errors/index"), exports);
-// Functional helpers (Result pattern)
-var funcs_1 = require("./funcs");
-Object.defineProperty(exports, "trackLead", { enumerable: true, get: function () { return funcs_1.trackLead; } });
-Object.defineProperty(exports, "trackSale", { enumerable: true, get: function () { return funcs_1.trackSale; } });
-// Result type utilities
-var result_1 = require("./types/result");
-Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_1.ok; } });
-Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_1.err; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vigneshreddy/cms-sdk",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Official TypeScript SDK for CutMeShort CMS API",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -10,21 +10,6 @@
       "require": "./dist/src/index.js",
       "import": "./dist/src/index.js",
       "types": "./dist/src/index.d.ts"
-    },
-    "./client": {
-      "require": "./dist/src/client.js",
-      "import": "./dist/src/client.js",
-      "types": "./dist/src/client.d.ts"
-    },
-    "./errors": {
-      "require": "./dist/src/errors/index.js",
-      "import": "./dist/src/errors/index.js",
-      "types": "./dist/src/errors/index.d.ts"
-    },
-    "./funcs": {
-      "require": "./dist/src/funcs/index.js",
-      "import": "./dist/src/funcs/index.js",
-      "types": "./dist/src/funcs/index.d.ts"
     }
   },
   "files": [
@@ -43,9 +28,15 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/YOUR_USERNAME/cms-sdk"
+    "url": "https://github.com/vigneshreddy/cms-sdk.git"
+  },
+  "homepage": "https://github.com/vigneshreddy/cms-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/vigneshreddy/cms-sdk/issues"
+  },
+  "engines": {
+    "node": ">=18"
   },
-  "homepage": "https://github.com/YOUR_USERNAME/cms-sdk#readme",
   "publishConfig": {
     "access": "public"
   },

package/dist/src/funcs/index.d.ts

@@ -1,2 +0,0 @@
-export { trackLead, type TrackLeadError } from "./trackLead";
-export { trackSale, type TrackSaleError } from "./trackSale";

package/dist/src/funcs/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackSale = exports.trackLead = void 0;
-var trackLead_1 = require("./trackLead");
-Object.defineProperty(exports, "trackLead", { enumerable: true, get: function () { return trackLead_1.trackLead; } });
-var trackSale_1 = require("./trackSale");
-Object.defineProperty(exports, "trackSale", { enumerable: true, get: function () { return trackSale_1.trackSale; } });

package/dist/src/funcs/trackLead.d.ts

@@ -1,44 +0,0 @@
-import { CMS, type LeadPayload } from "../client";
-import type { TrackResponse } from "../generated/api";
-import { Result } from "../types/result";
-import { CMSAPIError, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, BadGatewayError, ServiceUnavailableError, GatewayTimeoutError } from "../errors";
-export type TrackLeadError = BadRequestError | UnauthorizedError | ForbiddenError | NotFoundError | ConflictError | UnprocessableEntityError | RateLimitError | InternalServerError | BadGatewayError | ServiceUnavailableError | GatewayTimeoutError | CMSAPIError;
-/**
- * Track a lead for a short link.
- *
- * Functional helper that returns a Result instead of throwing.
- * This allows for explicit error handling without try/catch.
- *
- * This helper automatically wraps the user-provided data so that the
- * underlying SDK receives:
- *
- * {
- *   type: "lead",
- *   lead: { ...userData }
- * }
- *
- * @param client - The CMSSDK instance
- * @param leadData - Arbitrary user-provided lead data
- * @returns A Result containing either the TrackResponse or an error
- *
- * @example
- * ```ts
- * import { CMS } from "cms/client";
- * import { trackLead } from "cms/funcs/trackLead";
- *
- * const sdk = new CMS({ apiKey: "sk_test_123" });
- *
- * const res = await trackLead(sdk, {
- *   clickId: "dub_123",
- *   eventName: "signup_started",
- *   customerId: "user_42",
- * });
- *
- * if (res.ok) {
- *   console.log("Success:", res.value);
- * } else {
- *   console.error("Error:", res.error);
- * }
- * ```
- */
-export declare function trackLead(client: CMS, leadData: LeadPayload): Promise<Result<TrackResponse, TrackLeadError>>;

package/dist/src/funcs/trackLead.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackLead = trackLead;
-const result_1 = require("../types/result");
-const errors_1 = require("../errors");
-/**
- * Track a lead for a short link.
- *
- * Functional helper that returns a Result instead of throwing.
- * This allows for explicit error handling without try/catch.
- *
- * This helper automatically wraps the user-provided data so that the
- * underlying SDK receives:
- *
- * {
- *   type: "lead",
- *   lead: { ...userData }
- * }
- *
- * @param client - The CMSSDK instance
- * @param leadData - Arbitrary user-provided lead data
- * @returns A Result containing either the TrackResponse or an error
- *
- * @example
- * ```ts
- * import { CMS } from "cms/client";
- * import { trackLead } from "cms/funcs/trackLead";
- *
- * const sdk = new CMS({ apiKey: "sk_test_123" });
- *
- * const res = await trackLead(sdk, {
- *   clickId: "dub_123",
- *   eventName: "signup_started",
- *   customerId: "user_42",
- * });
- *
- * if (res.ok) {
- *   console.log("Success:", res.value);
- * } else {
- *   console.error("Error:", res.error);
- * }
- * ```
- */
-async function trackLead(client, leadData) {
-    try {
-        const value = await client.trackLead(leadData);
-        return (0, result_1.ok)(value);
-    }
-    catch (error) {
-        if (error instanceof errors_1.CMSAPIError) {
-            return (0, result_1.err)(error);
-        }
-        return (0, result_1.err)(new errors_1.CMSAPIError(error instanceof Error ? error.message : "Unknown error", -1, "client_error", error));
-    }
-}

package/dist/src/funcs/trackSale.d.ts

@@ -1,46 +0,0 @@
-import { CMS, type SalePayload } from "../client";
-import type { TrackResponse } from "../generated/api";
-import { Result } from "../types/result";
-import { CMSAPIError, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, BadGatewayError, ServiceUnavailableError, GatewayTimeoutError } from "../errors";
-export type TrackSaleError = BadRequestError | UnauthorizedError | ForbiddenError | NotFoundError | ConflictError | UnprocessableEntityError | RateLimitError | InternalServerError | BadGatewayError | ServiceUnavailableError | GatewayTimeoutError | CMSAPIError;
-/**
- * Track a sale for a short link.
- *
- * Functional helper that returns a Result instead of throwing.
- * This allows for explicit error handling without try/catch.
- *
- * This helper automatically wraps the user-provided data so that the
- * underlying SDK receives:
- *
- * {
- *   type: "sale",
- *   sale: { ...userData }
- * }
- *
- * @param client - The CMSSDK instance
- * @param saleData - Arbitrary user-provided sale data
- * @returns A Result containing either the TrackResponse or an error
- *
- * @example
- * ```ts
- * import { CMS } from "cms/client";
- * import { trackSale } from "cms/funcs/trackSale";
- *
- * const sdk = new CMS({ apiKey: "sk_test_123" });
- *
- * const res = await trackSale(sdk, {
- *   clickId: "dub_123",
- *   eventName: "purchase_completed",
- *   invoiceId: "inv_987",
- *   amount: 4999,
- *   currency: "USD",
- * });
- *
- * if (res.ok) {
- *   console.log("Success:", res.value);
- * } else {
- *   console.error("Error:", res.error);
- * }
- * ```
- */
-export declare function trackSale(client: CMS, saleData: SalePayload): Promise<Result<TrackResponse, TrackSaleError>>;

package/dist/src/funcs/trackSale.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackSale = trackSale;
-const result_1 = require("../types/result");
-const errors_1 = require("../errors");
-/**
- * Track a sale for a short link.
- *
- * Functional helper that returns a Result instead of throwing.
- * This allows for explicit error handling without try/catch.
- *
- * This helper automatically wraps the user-provided data so that the
- * underlying SDK receives:
- *
- * {
- *   type: "sale",
- *   sale: { ...userData }
- * }
- *
- * @param client - The CMSSDK instance
- * @param saleData - Arbitrary user-provided sale data
- * @returns A Result containing either the TrackResponse or an error
- *
- * @example
- * ```ts
- * import { CMS } from "cms/client";
- * import { trackSale } from "cms/funcs/trackSale";
- *
- * const sdk = new CMS({ apiKey: "sk_test_123" });
- *
- * const res = await trackSale(sdk, {
- *   clickId: "dub_123",
- *   eventName: "purchase_completed",
- *   invoiceId: "inv_987",
- *   amount: 4999,
- *   currency: "USD",
- * });
- *
- * if (res.ok) {
- *   console.log("Success:", res.value);
- * } else {
- *   console.error("Error:", res.error);
- * }
- * ```
- */
-async function trackSale(client, saleData) {
-    try {
-        const value = await client.trackSale(saleData);
-        return (0, result_1.ok)(value);
-    }
-    catch (error) {
-        if (error instanceof errors_1.CMSAPIError) {
-            return (0, result_1.err)(error);
-        }
-        return (0, result_1.err)(new errors_1.CMSAPIError(error instanceof Error ? error.message : "Unknown error", -1, "client_error", error));
-    }
-}