@vigneshreddy/cms-sdk 1.0.13 → 1.0.15

package/dist/src/funcs/common.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPathString = exports.serializeDataIfNeeded = exports.replaceWithSerializableTypeIfNeeded = exports.setSearchParams = exports.setOAuthToObject = exports.setBearerAuthToObject = exports.setBasicAuthToObject = exports.setApiKeyToObject = exports.assertParamExists = exports.DUMMY_BASE_URL = void 0;
+const base_1 = require("./base");
+exports.DUMMY_BASE_URL = 'https://example.com';
+/**
+ *
+ * @throws {RequiredError}
+ */
+const assertParamExists = function (functionName, paramName, paramValue) {
+    if (paramValue === null || paramValue === undefined) {
+        throw new base_1.RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
+    }
+};
+exports.assertParamExists = assertParamExists;
+const setApiKeyToObject = async function (object, keyParamName, configuration) {
+    if (configuration && configuration.apiKey) {
+        const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+            ? await configuration.apiKey(keyParamName)
+            : await configuration.apiKey;
+        object[keyParamName] = localVarApiKeyValue;
+    }
+};
+exports.setApiKeyToObject = setApiKeyToObject;
+const setBasicAuthToObject = function (object, configuration) {
+    if (configuration && (configuration.username || configuration.password)) {
+        object["auth"] = { username: configuration.username, password: configuration.password };
+    }
+};
+exports.setBasicAuthToObject = setBasicAuthToObject;
+const setBearerAuthToObject = async function (object, configuration) {
+    if (configuration && configuration.accessToken) {
+        const accessToken = typeof configuration.accessToken === 'function'
+            ? await configuration.accessToken()
+            : await configuration.accessToken;
+        object["Authorization"] = "Bearer " + accessToken;
+    }
+};
+exports.setBearerAuthToObject = setBearerAuthToObject;
+const setOAuthToObject = async function (object, name, scopes, configuration) {
+    if (configuration && configuration.accessToken) {
+        const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
+            ? await configuration.accessToken(name, scopes)
+            : await configuration.accessToken;
+        object["Authorization"] = "Bearer " + localVarAccessTokenValue;
+    }
+};
+exports.setOAuthToObject = setOAuthToObject;
+function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
+    if (parameter == null)
+        return;
+    if (typeof parameter === "object") {
+        if (Array.isArray(parameter) || parameter instanceof Set) {
+            parameter.forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
+        }
+        else {
+            Object.keys(parameter).forEach(currentKey => setFlattenedQueryParams(urlSearchParams, parameter[currentKey], `${key}${key !== '' ? '.' : ''}${currentKey}`));
+        }
+    }
+    else {
+        if (urlSearchParams.has(key)) {
+            urlSearchParams.append(key, parameter);
+        }
+        else {
+            urlSearchParams.set(key, parameter);
+        }
+    }
+}
+const setSearchParams = function (url, ...objects) {
+    const searchParams = new URLSearchParams(url.search);
+    setFlattenedQueryParams(searchParams, objects);
+    url.search = searchParams.toString();
+};
+exports.setSearchParams = setSearchParams;
+/**
+ * JSON serialization helper function which replaces instances of unserializable types with serializable ones.
+ * This function will run for every key-value pair encountered by JSON.stringify while traversing an object.
+ * Converting a set to a string will return an empty object, so an intermediate conversion to an array is required.
+ */
+// @ts-ignore
+const replaceWithSerializableTypeIfNeeded = function (key, value) {
+    if (value instanceof Set) {
+        return Array.from(value);
+    }
+    else {
+        return value;
+    }
+};
+exports.replaceWithSerializableTypeIfNeeded = replaceWithSerializableTypeIfNeeded;
+const serializeDataIfNeeded = function (value, requestOptions, configuration) {
+    const nonString = typeof value !== 'string';
+    const needsSerialization = nonString && configuration && configuration.isJsonMime
+        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
+        : nonString;
+    return needsSerialization
+        ? JSON.stringify(value !== undefined ? value : {}, exports.replaceWithSerializableTypeIfNeeded)
+        : (value || "");
+};
+exports.serializeDataIfNeeded = serializeDataIfNeeded;
+const toPathString = function (url) {
+    return url.pathname + url.search + url.hash;
+};
+exports.toPathString = toPathString;

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

@@ -0,0 +1,87 @@
+interface AWSv4Configuration {
+    options?: {
+        region?: string;
+        service?: string;
+    };
+    credentials?: {
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        sessionToken?: string;
+    };
+}
+export interface ConfigurationParameters {
+    apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>);
+    username?: string;
+    password?: string;
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
+    awsv4?: AWSv4Configuration;
+    basePath?: string;
+    serverIndex?: number;
+    baseOptions?: any;
+    formDataCtor?: new () => any;
+}
+export declare class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     */
+    apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>);
+    /**
+     * parameter for basic security
+     */
+    username?: string;
+    /**
+     * parameter for basic security
+     */
+    password?: string;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     */
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
+    /**
+     * parameter for aws4 signature security
+     * @param {Object} AWS4Signature - AWS4 Signature security
+     * @param {string} options.region - aws region
+     * @param {string} options.service - name of the service.
+     * @param {string} credentials.accessKeyId - aws access key id
+     * @param {string} credentials.secretAccessKey - aws access key
+     * @param {string} credentials.sessionToken - aws session token
+     * @memberof Configuration
+     */
+    awsv4?: AWSv4Configuration;
+    /**
+     * override base path
+     */
+    basePath?: string;
+    /**
+     * override server index
+     */
+    serverIndex?: number;
+    /**
+     * base options for axios calls
+     */
+    baseOptions?: any;
+    /**
+     * The FormData constructor that will be used to create multipart form data
+     * requests. You can inject this here so that execution environments that
+     * do not support the FormData class can still run the generated client.
+     *
+     * @type {new () => FormData}
+     */
+    formDataCtor?: new () => any;
+    constructor(param?: ConfigurationParameters);
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime: string): boolean;
+}
+export {};

package/dist/src/funcs/configuration.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+class Configuration {
+    constructor(param = {}) {
+        var _a;
+        this.apiKey = param.apiKey;
+        this.username = param.username;
+        this.password = param.password;
+        this.accessToken = param.accessToken;
+        this.awsv4 = param.awsv4;
+        this.basePath = param.basePath;
+        this.serverIndex = param.serverIndex;
+        this.baseOptions = {
+            ...param.baseOptions,
+            headers: {
+                ...(_a = param.baseOptions) === null || _a === void 0 ? void 0 : _a.headers,
+            },
+        };
+        this.formDataCtor = param.formDataCtor;
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+}
+exports.Configuration = Configuration;

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

@@ -0,0 +1,4 @@
+export * from "./api";
+export * from "./base";
+export * from "./common";
+export * from "./configuration";

package/dist/src/funcs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+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 });
+__exportStar(require("./api"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./configuration"), exports);

package/dist/src/index.d.ts

@@ -1,2 +1,7 @@
 export { CMS } from "./client";
+export type { CMSConfig, RequestOptions, LeadPayload, SalePayload } from "./client";
 export { CMSAPIError } from "./errors";
+export { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, BadGatewayError, ServiceUnavailableError, GatewayTimeoutError, createSpecificError, } from "./errors/specific";
+export { validateLeadPayload, validateSalePayload, validateCMSConfig, sanitizeForLogging } from "./validations/validation";
+export type { LeadPayloadInput, SalePayloadInput, CMSConfigInput } from "./validations/validation";
+export { SDK_VERSION, API_CONFIG, RETRY_CONFIG, VALIDATION_CONSTRAINTS, ERROR_MESSAGES, HTTP_HEADERS, SENSITIVE_FIELDS, } from "./constants/constants";

package/dist/src/index.js

@@ -1,7 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CMSAPIError = exports.CMS = void 0;
+exports.SENSITIVE_FIELDS = exports.HTTP_HEADERS = exports.ERROR_MESSAGES = exports.VALIDATION_CONSTRAINTS = exports.RETRY_CONFIG = exports.API_CONFIG = exports.SDK_VERSION = exports.sanitizeForLogging = exports.validateCMSConfig = exports.validateSalePayload = exports.validateLeadPayload = 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.CMSAPIError = exports.CMS = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "CMS", { enumerable: true, get: function () { return client_1.CMS; } });
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "CMSAPIError", { enumerable: true, get: function () { return errors_1.CMSAPIError; } });
+var specific_1 = require("./errors/specific");
+Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return specific_1.BadRequestError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return specific_1.UnauthorizedError; } });
+Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return specific_1.ForbiddenError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return specific_1.NotFoundError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return specific_1.ConflictError; } });
+Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, get: function () { return specific_1.UnprocessableEntityError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return specific_1.RateLimitError; } });
+Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return specific_1.InternalServerError; } });
+Object.defineProperty(exports, "BadGatewayError", { enumerable: true, get: function () { return specific_1.BadGatewayError; } });
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return specific_1.ServiceUnavailableError; } });
+Object.defineProperty(exports, "GatewayTimeoutError", { enumerable: true, get: function () { return specific_1.GatewayTimeoutError; } });
+Object.defineProperty(exports, "createSpecificError", { enumerable: true, get: function () { return specific_1.createSpecificError; } });
+var validation_1 = require("./validations/validation");
+Object.defineProperty(exports, "validateLeadPayload", { enumerable: true, get: function () { return validation_1.validateLeadPayload; } });
+Object.defineProperty(exports, "validateSalePayload", { enumerable: true, get: function () { return validation_1.validateSalePayload; } });
+Object.defineProperty(exports, "validateCMSConfig", { enumerable: true, get: function () { return validation_1.validateCMSConfig; } });
+Object.defineProperty(exports, "sanitizeForLogging", { enumerable: true, get: function () { return validation_1.sanitizeForLogging; } });
+// Export constants for advanced configuration
+var constants_1 = require("./constants/constants");
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return constants_1.SDK_VERSION; } });
+Object.defineProperty(exports, "API_CONFIG", { enumerable: true, get: function () { return constants_1.API_CONFIG; } });
+Object.defineProperty(exports, "RETRY_CONFIG", { enumerable: true, get: function () { return constants_1.RETRY_CONFIG; } });
+Object.defineProperty(exports, "VALIDATION_CONSTRAINTS", { enumerable: true, get: function () { return constants_1.VALIDATION_CONSTRAINTS; } });
+Object.defineProperty(exports, "ERROR_MESSAGES", { enumerable: true, get: function () { return constants_1.ERROR_MESSAGES; } });
+Object.defineProperty(exports, "HTTP_HEADERS", { enumerable: true, get: function () { return constants_1.HTTP_HEADERS; } });
+Object.defineProperty(exports, "SENSITIVE_FIELDS", { enumerable: true, get: function () { return constants_1.SENSITIVE_FIELDS; } });

package/dist/src/rate-limiter.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Token bucket rate limiter for controlling request rate
+ * Prevents the SDK from sending too many requests too quickly
+ */
+export interface RateLimiterOptions {
+    /** Maximum number of requests allowed per time window */
+    maxRequests: number;
+    /** Time window in milliseconds */
+    windowMs: number;
+    /** Called when rate limit is exceeded */
+    onLimitExceeded?: (remaining: number) => void;
+}
+export declare class RateLimiter {
+    private maxRequests;
+    private windowMs;
+    private tokens;
+    private lastRefillTime;
+    private onLimitExceeded?;
+    constructor(options: RateLimiterOptions);
+    /**
+     * Try to consume one token
+     * Returns true if request should be allowed, false if rate limited
+     */
+    tryConsume(): boolean;
+    /**
+     * Get current number of available tokens
+     */
+    getAvailableTokens(): number;
+    /**
+     * Get milliseconds until next token becomes available
+     */
+    getWaitTime(): number;
+    /**
+     * Reset the rate limiter
+     */
+    reset(): void;
+    /**
+     * Refill tokens based on elapsed time
+     */
+    private refill;
+}
+/**
+ * Pre-configured rate limiters for common scenarios
+ */
+export declare const RATE_LIMITER_PRESETS: {
+    /**
+     * Conservative: 10 requests per second (good for test/demo)
+     */
+    readonly CONSERVATIVE: {
+        readonly maxRequests: 10;
+        readonly windowMs: 1000;
+    };
+    /**
+     * Standard: 100 requests per second (suitable for production)
+     */
+    readonly STANDARD: {
+        readonly maxRequests: 100;
+        readonly windowMs: 1000;
+    };
+    /**
+     * Aggressive: 1000 requests per second (for high-volume scenarios)
+     */
+    readonly AGGRESSIVE: {
+        readonly maxRequests: 1000;
+        readonly windowMs: 1000;
+    };
+    /**
+     * Unlimited: No rate limiting (use with caution)
+     */
+    readonly UNLIMITED: {
+        readonly maxRequests: number;
+        readonly windowMs: 1000;
+    };
+};

package/dist/src/rate-limiter.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Token bucket rate limiter for controlling request rate
+ * Prevents the SDK from sending too many requests too quickly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RATE_LIMITER_PRESETS = exports.RateLimiter = void 0;
+class RateLimiter {
+    constructor(options) {
+        this.maxRequests = options.maxRequests;
+        this.windowMs = options.windowMs;
+        this.tokens = options.maxRequests;
+        this.lastRefillTime = Date.now();
+        this.onLimitExceeded = options.onLimitExceeded;
+    }
+    /**
+     * Try to consume one token
+     * Returns true if request should be allowed, false if rate limited
+     */
+    tryConsume() {
+        this.refill();
+        if (this.tokens > 0) {
+            this.tokens -= 1;
+            return true;
+        }
+        if (this.onLimitExceeded) {
+            this.onLimitExceeded(this.tokens);
+        }
+        return false;
+    }
+    /**
+     * Get current number of available tokens
+     */
+    getAvailableTokens() {
+        this.refill();
+        return this.tokens;
+    }
+    /**
+     * Get milliseconds until next token becomes available
+     */
+    getWaitTime() {
+        if (this.tokens > 0) {
+            return 0;
+        }
+        const timeSinceRefill = Date.now() - this.lastRefillTime;
+        const timePerToken = this.windowMs / this.maxRequests;
+        return Math.ceil(timePerToken - timeSinceRefill);
+    }
+    /**
+     * Reset the rate limiter
+     */
+    reset() {
+        this.tokens = this.maxRequests;
+        this.lastRefillTime = Date.now();
+    }
+    /**
+     * Refill tokens based on elapsed time
+     */
+    refill() {
+        const now = Date.now();
+        const timePassed = now - this.lastRefillTime;
+        if (timePassed >= this.windowMs) {
+            // Full reset if entire window has passed
+            this.tokens = this.maxRequests;
+            this.lastRefillTime = now;
+        }
+        else if (timePassed > 0) {
+            // Partial refill based on time passed
+            const refillRate = this.maxRequests / this.windowMs;
+            const tokensToAdd = (timePassed * refillRate);
+            this.tokens = Math.min(this.maxRequests, this.tokens + tokensToAdd);
+            this.lastRefillTime = now;
+        }
+    }
+}
+exports.RateLimiter = RateLimiter;
+/**
+ * Pre-configured rate limiters for common scenarios
+ */
+exports.RATE_LIMITER_PRESETS = {
+    /**
+     * Conservative: 10 requests per second (good for test/demo)
+     */
+    CONSERVATIVE: {
+        maxRequests: 10,
+        windowMs: 1000,
+    },
+    /**
+     * Standard: 100 requests per second (suitable for production)
+     */
+    STANDARD: {
+        maxRequests: 100,
+        windowMs: 1000,
+    },
+    /**
+     * Aggressive: 1000 requests per second (for high-volume scenarios)
+     */
+    AGGRESSIVE: {
+        maxRequests: 1000,
+        windowMs: 1000,
+    },
+    /**
+     * Unlimited: No rate limiting (use with caution)
+     */
+    UNLIMITED: {
+        maxRequests: Infinity,
+        windowMs: 1000,
+    },
+};

package/dist/src/validation.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Input validation schemas using Zod
+ * Ensures all incoming data is sanitized and valid
+ */
+import { z } from "zod";
+export declare const CMSConfigSchema: z.ZodObject<{
+    apiKey: z.ZodEffects<z.ZodString, string, string>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    retryDelayMs: z.ZodOptional<z.ZodNumber>;
+    retryMaxDelayMs: z.ZodOptional<z.ZodNumber>;
+    retryOnStatuses: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    retryOnNetworkError: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    timeout?: number | undefined;
+    baseUrl?: string | undefined;
+    maxRetries?: number | undefined;
+    retryDelayMs?: number | undefined;
+    retryMaxDelayMs?: number | undefined;
+    retryOnStatuses?: number[] | undefined;
+    retryOnNetworkError?: boolean | undefined;
+}, {
+    apiKey: string;
+    timeout?: number | undefined;
+    baseUrl?: string | undefined;
+    maxRetries?: number | undefined;
+    retryDelayMs?: number | undefined;
+    retryMaxDelayMs?: number | undefined;
+    retryOnStatuses?: number[] | undefined;
+    retryOnNetworkError?: boolean | undefined;
+}>;
+export type CMSConfigInput = z.infer<typeof CMSConfigSchema>;
+export declare const LeadPayloadSchema: z.ZodObject<{
+    clickId: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodString;
+    customerExternalId: z.ZodString;
+    timestamp: z.ZodOptional<z.ZodString>;
+    customerId: z.ZodOptional<z.ZodString>;
+    customerName: z.ZodOptional<z.ZodString>;
+    customerEmail: z.ZodOptional<z.ZodString>;
+    customerAvatar: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["deferred"]>>;
+}, "strip", z.ZodTypeAny, {
+    eventName: string;
+    customerExternalId: string;
+    clickId?: string | undefined;
+    timestamp?: string | undefined;
+    customerId?: string | undefined;
+    customerName?: string | undefined;
+    customerEmail?: string | undefined;
+    customerAvatar?: string | undefined;
+    mode?: "deferred" | undefined;
+}, {
+    eventName: string;
+    customerExternalId: string;
+    clickId?: string | undefined;
+    timestamp?: string | undefined;
+    customerId?: string | undefined;
+    customerName?: string | undefined;
+    customerEmail?: string | undefined;
+    customerAvatar?: string | undefined;
+    mode?: "deferred" | undefined;
+}>;
+export type LeadPayloadInput = z.infer<typeof LeadPayloadSchema>;
+export declare const SalePayloadSchema: z.ZodObject<{
+    clickId: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodOptional<z.ZodString>;
+    invoiceId: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    customerId: z.ZodOptional<z.ZodString>;
+    customerExternalId: z.ZodOptional<z.ZodString>;
+    customerName: z.ZodOptional<z.ZodString>;
+    customerEmail: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["deferred"]>>;
+}, "strip", z.ZodTypeAny, {
+    invoiceId: string;
+    amount: number;
+    clickId?: string | undefined;
+    eventName?: string | undefined;
+    customerExternalId?: string | undefined;
+    timestamp?: string | undefined;
+    customerId?: string | undefined;
+    customerName?: string | undefined;
+    customerEmail?: string | undefined;
+    mode?: "deferred" | undefined;
+    currency?: string | undefined;
+}, {
+    invoiceId: string;
+    amount: number;
+    clickId?: string | undefined;
+    eventName?: string | undefined;
+    customerExternalId?: string | undefined;
+    timestamp?: string | undefined;
+    customerId?: string | undefined;
+    customerName?: string | undefined;
+    customerEmail?: string | undefined;
+    mode?: "deferred" | undefined;
+    currency?: string | undefined;
+}>;
+export type SalePayloadInput = z.infer<typeof SalePayloadSchema>;
+/**
+ * Validates input data and throws detailed error if invalid
+ */
+export declare function validateLeadPayload(data: unknown): LeadPayloadInput;
+export declare function validateSalePayload(data: unknown): SalePayloadInput;
+export declare function validateCMSConfig(data: unknown): CMSConfigInput;
+/**
+ * Sanitizes sensitive data for logging/errors
+ * Removes API keys, tokens, and other credentials
+ */
+export declare function sanitizeForLogging(obj: any): any;
+/**
+ * Redacts API key from error messages
+ */
+export declare function redactApiKey(message: string, apiKey?: string): string;