@vigneshreddy/cms-sdk 1.0.14 → 1.0.15

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;

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;