@vigneshreddy/cms-sdk 1.0.13 → 1.0.15

package/dist/src/errors.js

@@ -23,12 +23,19 @@ Object.defineProperty(exports, "createSpecificError", { enumerable: true, get: f
 /**
  * Parses fetch/network errors into a clean CMSAPIError (or specific subclass)
  * Uses specific error types when possible for better type safety
+ * Sanitizes sensitive information before storing
  */
 function handleApiError(error, request, response) {
     var _a, _b, _c, _d, _e, _f;
     if (error instanceof base_1.CMSAPIError) {
         throw error; // preserve original error metadata/type
     }
+    const isHtmlResponse = (data) => {
+        if (typeof data !== "string")
+            return false;
+        const trimmed = data.trim().toLowerCase();
+        return trimmed.startsWith("<!doctype") || trimmed.startsWith("<html") || trimmed.startsWith("<!-");
+    };
     const getBackendErrorMessage = (data) => {
         var _a;
         const directMessage = typeof (data === null || data === void 0 ? void 0 : data.message) === "string" ? data.message.trim() : "";
@@ -55,7 +62,8 @@ function handleApiError(error, request, response) {
                 return firstObjectErrorText.errorMessage.trim();
             }
         }
-        if (typeof data === "string" && data.trim()) {
+        // Ignore HTML responses (e.g., 404 pages)
+        if (typeof data === "string" && data.trim() && !isHtmlResponse(data)) {
             return data.trim();
         }
         return undefined;
@@ -64,30 +72,48 @@ function handleApiError(error, request, response) {
         if (!req || typeof req !== "object")
             return undefined;
         const r = req;
-        return {
+        const sanitized = {
             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,
         };
+        // Only include headers if they don't contain sensitive data
+        if (typeof r.headers === "object" && r.headers !== null) {
+            const headersObj = r.headers;
+            const safeHeaders = {};
+            for (const [key, value] of Object.entries(headersObj)) {
+                const lowerKey = key.toLowerCase();
+                // Exclude authorization and api-key headers
+                if (!lowerKey.includes("authorization") &&
+                    !lowerKey.includes("api-key") &&
+                    !lowerKey.includes("token")) {
+                    safeHeaders[key] = value;
+                }
+            }
+            if (Object.keys(safeHeaders).length > 0) {
+                sanitized.headers = safeHeaders;
+            }
+        }
+        return sanitized;
     };
     // Error with response from server
     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 backendMessage = getBackendErrorMessage(res.data);
+        const isHtml = isHtmlResponse(res.data);
+        const backendMessage = isHtml ? undefined : getBackendErrorMessage(res.data);
         const fallbackMessage = `CMS API Error: ${statusCode} - ${(_d = res.statusText) !== null && _d !== void 0 ? _d : "Unknown API Error"}`;
         const message = backendMessage !== null && backendMessage !== void 0 ? backendMessage : fallbackMessage;
+        // Don't pass HTML blobs as rawError
+        const rawError = isHtml ? undefined : ((_e = res.data) !== null && _e !== void 0 ? _e : error);
         // Prefer typed error subclasses when possible
-        const typedError = (0, specific_1.createSpecificError)(statusCode, message, (_e = res.data) !== null && _e !== void 0 ? _e : error);
+        const typedError = (0, specific_1.createSpecificError)(statusCode, message, rawError);
         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,
+            data: isHtml ? undefined : res.data,
             headers: res.headers,
         };
         throw typedError;

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

@@ -0,0 +1,192 @@
+import type { Configuration } from './configuration';
+import type { RequestArgs, RequestOptions } from './base';
+import { BaseAPI } from './base';
+export type TrackLeadRequest = {
+    /**
+     * The `cms_id` from the cookie.
+     */
+    'clickId': string;
+    'eventName': string;
+    /**
+     * Unique User ID. Used for deduplication (user cannot signup twice).
+     */
+    'customerExternalId': 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 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).
+     */
+    '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;
+}
+export interface TrackSaleRequest {
+    /**
+     * The `dub_id` from the cookie.
+     */
+    'clickId': string;
+    'eventName': string;
+    /**
+     * 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;
+    /**
+     * The value of the sale in cents.
+     */
+    'amount': number;
+    /**
+     * Three-letter currency code.
+     */
+    'currency': string;
+}
+/**
+ * EventsApi - axios parameter creator
+ */
+export declare const EventsApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     *
+     * @summary Track a Lead
+     * @param {TrackLeadRequest} trackLeadRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackLead: (trackLeadRequest: TrackLeadRequest, options?: RequestOptions) => Promise<RequestArgs>;
+    /**
+     *
+     * @summary Track a Sale
+     * @param {TrackSaleRequest} trackSaleRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackSale: (trackSaleRequest: TrackSaleRequest, options?: RequestOptions) => Promise<RequestArgs>;
+};
+/**
+ * EventsApi - functional programming interface
+ */
+export declare const EventsApiFp: (configuration?: Configuration) => {
+    /**
+     *
+     * @summary Track a Lead
+     * @param {TrackLeadRequest} trackLeadRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackLead(trackLeadRequest: TrackLeadRequest, options?: RequestOptions, basePathOverride?: string): Promise<TrackResponse>;
+    /**
+     *
+     * @summary Track a Sale
+     * @param {TrackSaleRequest} trackSaleRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackSale(trackSaleRequest: TrackSaleRequest, options?: RequestOptions, basePathOverride?: string): Promise<TrackResponse>;
+};
+/**
+ * EventsApi - factory interface
+ */
+export declare const EventsApiFactory: (configuration?: Configuration, basePath?: string) => {
+    /**
+     *
+     * @summary Track a Lead
+     * @param {TrackLeadRequest} trackLeadRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackLead(trackLeadRequest: TrackLeadRequest, options?: RequestOptions): Promise<TrackResponse>;
+    /**
+     *
+     * @summary Track a Sale
+     * @param {TrackSaleRequest} trackSaleRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackSale(trackSaleRequest: TrackSaleRequest, options?: RequestOptions): Promise<TrackResponse>;
+};
+/**
+ * EventsApi - object-oriented interface
+ */
+export declare class EventsApi extends BaseAPI {
+    /**
+     *
+     * @summary Track a Lead
+     * @param {TrackLeadRequest} trackLeadRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackLead(trackLeadRequest: TrackLeadRequest, options?: RequestOptions): Promise<TrackResponse>;
+    /**
+     *
+     * @summary Track a Sale
+     * @param {TrackSaleRequest} trackSaleRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackSale(trackSaleRequest: TrackSaleRequest, options?: RequestOptions): Promise<TrackResponse>;
+}

package/dist/src/funcs/api.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsApi = exports.EventsApiFactory = exports.EventsApiFp = exports.EventsApiAxiosParamCreator = void 0;
+const common_1 = require("./common");
+// @ts-ignore
+const base_1 = require("./base");
+/**
+ * EventsApi - axios parameter creator
+ */
+const EventsApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         *
+         * @summary Track a Lead
+         * @param {TrackLeadRequest} trackLeadRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        trackLead: async (trackLeadRequest, options = {}) => {
+            // verify required parameter 'trackLeadRequest' is not null or undefined
+            (0, common_1.assertParamExists)('trackLead', 'trackLeadRequest', trackLeadRequest);
+            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;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication bearerAuth required
+            // http bearer authentication required
+            await (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = 'application/json';
+            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(trackLeadRequest, localVarRequestOptions, configuration);
+            return {
+                url: (0, common_1.toPathString)(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Track a Sale
+         * @param {TrackSaleRequest} trackSaleRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        trackSale: async (trackSaleRequest, options = {}) => {
+            // verify required parameter 'trackSaleRequest' is not null or undefined
+            (0, common_1.assertParamExists)('trackSale', 'trackSaleRequest', trackSaleRequest);
+            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;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication bearerAuth required
+            // http bearer authentication required
+            await (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = 'application/json';
+            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(trackSaleRequest, localVarRequestOptions, configuration);
+            return {
+                url: (0, common_1.toPathString)(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+exports.EventsApiAxiosParamCreator = EventsApiAxiosParamCreator;
+/**
+ * EventsApi - functional programming interface
+ */
+const EventsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = (0, exports.EventsApiAxiosParamCreator)(configuration);
+    return {
+        /**
+         *
+         * @summary Track a Lead
+         * @param {TrackLeadRequest} trackLeadRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async trackLead(trackLeadRequest, options, basePathOverride) {
+            var _a, _b, _c, _d, _e;
+            const localVarAxiosArgs = await localVarAxiosParamCreator.trackLead(trackLeadRequest, options !== null && options !== void 0 ? options : {});
+            const localVarOperationServerIndex = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.serverIndex) !== null && _a !== void 0 ? _a : 0;
+            const localVarOperationServerBasePath = (_c = (_b = base_1.operationServerMap['EventsApi.trackLead']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
+            const basePath = (_e = (_d = basePathOverride !== null && basePathOverride !== void 0 ? basePathOverride : localVarOperationServerBasePath) !== null && _d !== void 0 ? _d : configuration === null || configuration === void 0 ? void 0 : configuration.basePath) !== null && _e !== void 0 ? _e : base_1.BASE_PATH;
+            return performFetchRequest(localVarAxiosArgs, basePath);
+        },
+        /**
+         *
+         * @summary Track a Sale
+         * @param {TrackSaleRequest} trackSaleRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async trackSale(trackSaleRequest, options, basePathOverride) {
+            var _a, _b, _c, _d, _e;
+            const localVarAxiosArgs = await localVarAxiosParamCreator.trackSale(trackSaleRequest, options !== null && options !== void 0 ? options : {});
+            const localVarOperationServerIndex = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.serverIndex) !== null && _a !== void 0 ? _a : 0;
+            const localVarOperationServerBasePath = (_c = (_b = base_1.operationServerMap['EventsApi.trackSale']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
+            const basePath = (_e = (_d = basePathOverride !== null && basePathOverride !== void 0 ? basePathOverride : localVarOperationServerBasePath) !== null && _d !== void 0 ? _d : configuration === null || configuration === void 0 ? void 0 : configuration.basePath) !== null && _e !== void 0 ? _e : base_1.BASE_PATH;
+            return performFetchRequest(localVarAxiosArgs, basePath);
+        },
+    };
+};
+exports.EventsApiFp = EventsApiFp;
+/**
+ * EventsApi - factory interface
+ */
+const EventsApiFactory = function (configuration, basePath) {
+    const localVarFp = (0, exports.EventsApiFp)(configuration);
+    return {
+        /**
+         *
+         * @summary Track a Lead
+         * @param {TrackLeadRequest} trackLeadRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        trackLead(trackLeadRequest, options) {
+            return localVarFp.trackLead(trackLeadRequest, options, basePath);
+        },
+        /**
+         *
+         * @summary Track a Sale
+         * @param {TrackSaleRequest} trackSaleRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        trackSale(trackSaleRequest, options) {
+            return localVarFp.trackSale(trackSaleRequest, options, basePath);
+        },
+    };
+};
+exports.EventsApiFactory = EventsApiFactory;
+/**
+ * EventsApi - object-oriented interface
+ */
+class EventsApi extends base_1.BaseAPI {
+    /**
+     *
+     * @summary Track a Lead
+     * @param {TrackLeadRequest} trackLeadRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackLead(trackLeadRequest, options) {
+        return (0, exports.EventsApiFp)(this.configuration).trackLead(trackLeadRequest, options, this.basePath);
+    }
+    /**
+     *
+     * @summary Track a Sale
+     * @param {TrackSaleRequest} trackSaleRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    trackSale(trackSaleRequest, options) {
+        return (0, exports.EventsApiFp)(this.configuration).trackSale(trackSaleRequest, options, this.basePath);
+    }
+}
+exports.EventsApi = EventsApi;
+/**
+ * Internal helper that performs a fetch request based on the generated
+ * `RequestArgs` and normalizes errors into an Axios-like shape so the
+ * existing error handling and retry logic in the SDK can continue to
+ * operate without changes.
+ */
+async function performFetchRequest(requestArgs, basePath) {
+    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") {
+        throw new Error("Global fetch API is not available. Please provide a fetch polyfill in this environment.");
+    }
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
+    const signal = controller === null || controller === void 0 ? void 0 : controller.signal;
+    let timeoutId;
+    if (controller && typeof timeout === "number" && timeout > 0) {
+        timeoutId = setTimeout(() => controller.abort(), timeout);
+    }
+    try {
+        const fetchOptions = { ...restOptions, signal };
+        // 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 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 === null || requestContentType === void 0 ? void 0 : requestContentType.toLowerCase().includes("application/json")) {
+                fetchOptions.body =
+                    typeof data === "string" ? data : JSON.stringify(data);
+            }
+            else {
+                fetchOptions.body = data;
+            }
+        }
+        const response = await fetch(url, fetchOptions);
+        const responseContentType = response.headers.get("content-type") || "";
+        const isJson = responseContentType.toLowerCase().includes("application/json");
+        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;
+        }
+        return dataResult;
+    }
+    catch (err) {
+        // Normalize fetch/AbortError/network errors into an Axios-style shape
+        if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
+            err.code = "ECONNABORTED";
+        }
+        if (!err.response) {
+            // Attach only minimal request info to avoid leaking sensitive data
+            err.request = { url };
+        }
+        throw err;
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { Configuration } from './configuration';
+export type RequestOptions = RequestInit & {
+    /**
+     * Optional request timeout in milliseconds.
+     * When provided, the client will abort the request after this duration.
+     */
+    timeout?: number;
+    /**
+     * Optional headers bag. This stays loosely typed to be compatible with
+     * any existing code that spreads arbitrary objects into headers.
+     */
+    headers?: Record<string, any>;
+};
+export declare const BASE_PATH: string;
+export declare const COLLECTION_FORMATS: {
+    csv: string;
+    ssv: string;
+    tsv: string;
+    pipes: string;
+};
+export interface RequestArgs {
+    url: string;
+    options: RequestOptions;
+}
+export declare class BaseAPI {
+    protected configuration: Configuration | undefined;
+    protected basePath: string;
+    /**
+     * Minimal base class that stores configuration and basePath.
+     * Concrete API classes are responsible for performing requests using
+     * the global `fetch` (or any polyfill provided by the consumer).
+     */
+    constructor(configuration?: Configuration, basePath?: string);
+}
+export declare class RequiredError extends Error {
+    field: string;
+    constructor(field: string, msg?: string);
+}
+interface ServerMap {
+    [key: string]: {
+        url: string;
+        description: string;
+    }[];
+}
+export declare const operationServerMap: ServerMap;
+export {};

package/dist/src/funcs/base.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationServerMap = exports.RequiredError = exports.BaseAPI = exports.COLLECTION_FORMATS = exports.BASE_PATH = void 0;
+const constants_1 = require("../constants/constants");
+exports.BASE_PATH = constants_1.API_CONFIG.BASE_URL.replace(/\/+$/, "");
+exports.COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+class BaseAPI {
+    /**
+     * Minimal base class that stores configuration and basePath.
+     * Concrete API classes are responsible for performing requests using
+     * the global `fetch` (or any polyfill provided by the consumer).
+     */
+    constructor(configuration, basePath = exports.BASE_PATH) {
+        var _a;
+        this.basePath = exports.BASE_PATH;
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = (_a = configuration.basePath) !== null && _a !== void 0 ? _a : basePath;
+        }
+        else {
+            this.basePath = basePath;
+        }
+    }
+}
+exports.BaseAPI = BaseAPI;
+;
+class RequiredError extends Error {
+    constructor(field, msg) {
+        super(msg);
+        this.field = field;
+        this.name = "RequiredError";
+    }
+}
+exports.RequiredError = RequiredError;
+exports.operationServerMap = {};

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

@@ -0,0 +1,20 @@
+import type { Configuration } from "./configuration";
+export declare const DUMMY_BASE_URL = "https://example.com";
+/**
+ *
+ * @throws {RequiredError}
+ */
+export declare const assertParamExists: (functionName: string, paramName: string, paramValue: unknown) => void;
+export declare const setApiKeyToObject: (object: any, keyParamName: string, configuration?: Configuration) => Promise<void>;
+export declare const setBasicAuthToObject: (object: any, configuration?: Configuration) => void;
+export declare const setBearerAuthToObject: (object: any, configuration?: Configuration) => Promise<void>;
+export declare const setOAuthToObject: (object: any, name: string, scopes: string[], configuration?: Configuration) => Promise<void>;
+export declare const setSearchParams: (url: URL, ...objects: any[]) => void;
+/**
+ * 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.
+ */
+export declare const replaceWithSerializableTypeIfNeeded: (key: string, value: any) => any;
+export declare const serializeDataIfNeeded: (value: any, requestOptions: any, configuration?: Configuration) => any;
+export declare const toPathString: (url: URL) => string;