@contentful/optimization-api-client 0.1.0-alpha

package/dist/index.cjs

@@ -0,0 +1,708 @@
+"use strict";
+var __webpack_modules__ = {
+    "./src/ApiClient.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>ApiClient
+        });
+        var _experience__rspack_import_0 = __webpack_require__("./src/experience/index.ts");
+        var _insights__rspack_import_1 = __webpack_require__("./src/insights/index.ts");
+        class ApiClient {
+            config;
+            experience;
+            insights;
+            constructor(config){
+                const { personalization, analytics, ...apiConfig } = config;
+                this.config = apiConfig;
+                this.experience = new _experience__rspack_import_0.A({
+                    ...apiConfig,
+                    ...personalization
+                });
+                this.insights = new _insights__rspack_import_1.A({
+                    ...apiConfig,
+                    ...analytics
+                });
+            }
+        }
+    },
+    "./src/ApiClientBase.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>src_ApiClientBase
+        });
+        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
+        const external_p_retry_namespaceObject = require("p-retry");
+        var external_p_retry_default = /*#__PURE__*/ __webpack_require__.n(external_p_retry_namespaceObject);
+        const logger = (0, dist.zP)('ApiClient:Retry');
+        const DEFAULT_INTERVAL_TIMEOUT = 0;
+        const DEFAULT_RETRY_COUNT = 1;
+        const RETRY_RESPONSE_STATUS = 503;
+        const HTTP_ERROR_RESPONSE_STATUS = 500;
+        class HttpError extends Error {
+            status;
+            constructor(message, status = HTTP_ERROR_RESPONSE_STATUS){
+                super(message);
+                Object.setPrototypeOf(this, HttpError.prototype);
+                this.status = status;
+            }
+        }
+        function createRetryFetchCallback({ apiName = 'Optimization', controller, fetchMethod = fetch, init, url }) {
+            return async ()=>{
+                try {
+                    const response = await fetchMethod(url, init);
+                    if (response.status === RETRY_RESPONSE_STATUS) throw new HttpError(`${apiName} API request to "${url.toString()}" failed with status: "[${response.status}] ${response.statusText}".`, RETRY_RESPONSE_STATUS);
+                    if (!response.ok) {
+                        const httpError = new Error(`Request to "${url.toString()}" failed with status: [${response.status}] ${response.statusText} - traceparent: ${response.headers.get('traceparent')}`);
+                        logger.error('Request failed with non-OK status:', httpError);
+                        controller.abort();
+                        return;
+                    }
+                    logger.debug(`Response from "${url.toString()}":`, response);
+                    return response;
+                } catch (error) {
+                    if (error instanceof HttpError && error.status === RETRY_RESPONSE_STATUS) throw error;
+                    logger.error(`Request to "${url.toString()}" failed:`, error);
+                    controller.abort();
+                }
+            };
+        }
+        function createRetryFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, intervalTimeout = DEFAULT_INTERVAL_TIMEOUT, onFailedAttempt, retries = DEFAULT_RETRY_COUNT } = {}) {
+            return async (url, init)=>{
+                const controller = new AbortController();
+                let retryResponse;
+                try {
+                    retryResponse = await external_p_retry_default()(createRetryFetchCallback({
+                        apiName,
+                        controller,
+                        fetchMethod,
+                        init,
+                        url
+                    }), {
+                        minTimeout: intervalTimeout,
+                        onFailedAttempt: (options)=>onFailedAttempt?.({
+                                ...options,
+                                apiName
+                            }),
+                        retries,
+                        signal: controller.signal
+                    });
+                } catch (error) {
+                    if (!(error instanceof Error) || 'AbortError' !== error.name) throw error;
+                }
+                if (!retryResponse) throw new Error(`${apiName} API request to "${url.toString()}" may not be retried.`);
+                return retryResponse;
+            };
+        }
+        const createTimeoutFetchMethod_logger = (0, dist.zP)('ApiClient:Timeout');
+        const DEFAULT_REQUEST_TIMEOUT = 3000;
+        function createTimeoutFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, onRequestTimeout, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
+            return async (url, init)=>{
+                const controller = new AbortController();
+                const id = setTimeout(()=>{
+                    if ('function' == typeof onRequestTimeout) onRequestTimeout({
+                        apiName
+                    });
+                    else createTimeoutFetchMethod_logger.error(`Request to "${url.toString()}" timed out`, new Error('Request timeout'));
+                    controller.abort();
+                }, requestTimeout);
+                const response = await fetchMethod(url, {
+                    ...init,
+                    signal: controller.signal
+                });
+                clearTimeout(id);
+                return response;
+            };
+        }
+        const createProtectedFetchMethod_logger = (0, dist.zP)('ApiClient:Fetch');
+        function createProtectedFetchMethod(options) {
+            try {
+                const timeoutFetchMethod = createTimeoutFetchMethod(options);
+                const retryFetchMethod = createRetryFetchMethod({
+                    ...options,
+                    fetchMethod: timeoutFetchMethod
+                });
+                return retryFetchMethod;
+            } catch (error) {
+                if (error instanceof Error) if ('AbortError' === error.name) createProtectedFetchMethod_logger.warn('Request aborted due to network issues. This request may not be retried.');
+                else createProtectedFetchMethod_logger.error('Request failed:', error);
+                throw error;
+            }
+        }
+        const Fetch = {
+            create: createProtectedFetchMethod
+        };
+        const fetch_Fetch = Fetch;
+        const src_fetch = fetch_Fetch;
+        const ApiClientBase_logger = (0, dist.zP)('ApiClient');
+        const DEFAULT_ENVIRONMENT = 'main';
+        class ApiClientBase {
+            name;
+            clientId;
+            environment;
+            fetch;
+            constructor(name, { fetchOptions, clientId, environment }){
+                this.clientId = clientId;
+                this.environment = environment ?? DEFAULT_ENVIRONMENT;
+                this.name = name;
+                this.fetch = src_fetch.create({
+                    ...fetchOptions ?? {},
+                    apiName: name
+                });
+            }
+            logRequestError(error, { requestName }) {
+                if (error instanceof Error) if ('AbortError' === error.name) ApiClientBase_logger.warn(`[${this.name}] "${requestName}" request aborted due to network issues. This request may not be retried.`);
+                else ApiClientBase_logger.error(`[${this.name}] "${requestName}" request failed:`, error);
+            }
+        }
+        const src_ApiClientBase = ApiClientBase;
+    },
+    "./src/builders/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            c: ()=>DEFAULT_PAGE_PROPERTIES,
+            e: ()=>builders_EventBuilder
+        });
+        var optimization_api_schemas_ = __webpack_require__("@contentful/optimization-api-schemas");
+        const external_es_toolkit_namespaceObject = require("es-toolkit");
+        const mini_namespaceObject = require("zod/mini");
+        const UniversalEventBuilderArgs = mini_namespaceObject.object({
+            campaign: mini_namespaceObject.optional(optimization_api_schemas_.Campaign),
+            locale: mini_namespaceObject.optional(mini_namespaceObject.string()),
+            location: mini_namespaceObject.optional(optimization_api_schemas_.GeoLocation),
+            page: mini_namespaceObject.optional(optimization_api_schemas_.Page),
+            screen: mini_namespaceObject.optional(optimization_api_schemas_.Screen),
+            userAgent: mini_namespaceObject.optional(mini_namespaceObject.string())
+        });
+        const ComponentViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+            componentId: mini_namespaceObject.string(),
+            experienceId: mini_namespaceObject.optional(mini_namespaceObject.string()),
+            variantIndex: mini_namespaceObject.optional(mini_namespaceObject.number()),
+            sticky: mini_namespaceObject.optional(mini_namespaceObject.boolean())
+        });
+        const IdentifyBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+            traits: mini_namespaceObject.optional(optimization_api_schemas_.Traits),
+            userId: mini_namespaceObject.string()
+        });
+        const PageViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+            properties: mini_namespaceObject.optional(mini_namespaceObject.partial(optimization_api_schemas_.Page))
+        });
+        const ScreenViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+            name: mini_namespaceObject.string(),
+            properties: optimization_api_schemas_.Properties
+        });
+        const TrackBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+            event: mini_namespaceObject.string(),
+            properties: mini_namespaceObject.optional(mini_namespaceObject.prefault(optimization_api_schemas_.Properties, {}))
+        });
+        const DEFAULT_PAGE_PROPERTIES = {
+            path: '',
+            query: {},
+            referrer: '',
+            search: '',
+            title: '',
+            url: ''
+        };
+        class EventBuilder {
+            app;
+            channel;
+            library;
+            getLocale;
+            getPageProperties;
+            getUserAgent;
+            constructor(config){
+                const { app, channel, library, getLocale, getPageProperties, getUserAgent } = config;
+                this.app = app;
+                this.channel = channel;
+                this.library = library;
+                this.getLocale = getLocale ?? (()=>'en-US');
+                this.getPageProperties = getPageProperties ?? (()=>DEFAULT_PAGE_PROPERTIES);
+                this.getUserAgent = getUserAgent ?? (()=>void 0);
+            }
+            buildUniversalEventProperties({ campaign = {}, locale, location, page, screen, userAgent }) {
+                const timestamp = new Date().toISOString();
+                return {
+                    channel: this.channel,
+                    context: {
+                        app: this.app,
+                        campaign,
+                        gdpr: {
+                            isConsentGiven: true
+                        },
+                        library: this.library,
+                        locale: locale ?? this.getLocale() ?? 'en-US',
+                        location,
+                        page: page ?? this.getPageProperties(),
+                        screen,
+                        userAgent: userAgent ?? this.getUserAgent()
+                    },
+                    messageId: crypto.randomUUID(),
+                    originalTimestamp: timestamp,
+                    sentAt: timestamp,
+                    timestamp
+                };
+            }
+            buildComponentView(args) {
+                const { componentId, experienceId, variantIndex, ...universal } = ComponentViewBuilderArgs.parse(args);
+                return {
+                    ...this.buildUniversalEventProperties(universal),
+                    type: 'component',
+                    componentType: 'Entry',
+                    componentId,
+                    experienceId,
+                    variantIndex: variantIndex ?? 0
+                };
+            }
+            buildFlagView(args) {
+                return {
+                    ...this.buildComponentView(args),
+                    componentType: 'Variable'
+                };
+            }
+            buildIdentify(args) {
+                const { traits = {}, userId, ...universal } = IdentifyBuilderArgs.parse(args);
+                return {
+                    ...this.buildUniversalEventProperties(universal),
+                    type: 'identify',
+                    traits,
+                    userId
+                };
+            }
+            buildPageView(args = {}) {
+                const { properties = {}, ...universal } = PageViewBuilderArgs.parse(args);
+                const pageProperties = this.getPageProperties();
+                const merged = (0, external_es_toolkit_namespaceObject.merge)({
+                    ...pageProperties,
+                    title: pageProperties.title ?? DEFAULT_PAGE_PROPERTIES.title
+                }, properties);
+                const { context: { screen: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
+                const context = optimization_api_schemas_.PageEventContext.parse(universalContext);
+                return {
+                    ...universalProperties,
+                    context,
+                    type: 'page',
+                    properties: merged
+                };
+            }
+            buildScreenView(args) {
+                const { name, properties, ...universal } = ScreenViewBuilderArgs.parse(args);
+                const { context: { page: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
+                const context = optimization_api_schemas_.ScreenEventContext.parse(universalContext);
+                return {
+                    ...universalProperties,
+                    context,
+                    type: 'screen',
+                    name,
+                    properties
+                };
+            }
+            buildTrack(args) {
+                const { event, properties = {}, ...universal } = TrackBuilderArgs.parse(args);
+                return {
+                    ...this.buildUniversalEventProperties(universal),
+                    type: 'track',
+                    event,
+                    properties
+                };
+            }
+        }
+        const builders_EventBuilder = EventBuilder;
+    },
+    "./src/experience/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            n: ()=>EXPERIENCE_BASE_URL,
+            A: ()=>experience
+        });
+        var optimization_api_schemas_ = __webpack_require__("@contentful/optimization-api-schemas");
+        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
+        var ApiClientBase = __webpack_require__("./src/ApiClientBase.ts");
+        const logger = (0, dist.zP)('ApiClient:Experience');
+        const EXPERIENCE_BASE_URL = 'https://experience.ninetailed.co/';
+        class ExperienceApiClient extends ApiClientBase.A {
+            baseUrl;
+            enabledFeatures;
+            ip;
+            locale;
+            plainText;
+            preflight;
+            constructor(config){
+                super('Experience', config);
+                const { baseUrl, enabledFeatures, ip, locale, plainText, preflight } = config;
+                this.baseUrl = baseUrl || EXPERIENCE_BASE_URL;
+                this.enabledFeatures = enabledFeatures;
+                this.ip = ip;
+                this.locale = locale;
+                this.plainText = plainText;
+                this.preflight = preflight;
+            }
+            async getProfile(id, options = {}) {
+                if (!id) throw new Error('Valid profile ID required.');
+                const requestName = 'Get Profile';
+                logger.info(`Sending "${requestName}" request`);
+                try {
+                    const response = await this.fetch(this.constructUrl(`v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${id}`, options), {
+                        method: 'GET'
+                    });
+                    const { data: { changes, experiences, profile } } = optimization_api_schemas_.ExperienceResponse.parse(await response.json());
+                    const data = {
+                        changes,
+                        personalizations: experiences,
+                        profile
+                    };
+                    logger.debug(`"${requestName}" request successfully completed`);
+                    return data;
+                } catch (error) {
+                    this.logRequestError(error, {
+                        requestName
+                    });
+                    throw error;
+                }
+            }
+            async makeProfileMutationRequest({ url, body, options }) {
+                return await this.fetch(this.constructUrl(url, options), {
+                    method: 'POST',
+                    headers: this.constructHeaders(options),
+                    body: JSON.stringify(body),
+                    keepalive: true
+                });
+            }
+            async createProfile({ events }, options = {}) {
+                const requestName = 'Create Profile';
+                logger.info(`Sending "${requestName}" request`);
+                const body = {
+                    events: optimization_api_schemas_.ExperienceEventArray.parse(events),
+                    options: this.constructBodyOptions(options)
+                };
+                logger.debug(`"${requestName}" request body:`, body);
+                try {
+                    const response = await this.makeProfileMutationRequest({
+                        url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles`,
+                        body,
+                        options
+                    });
+                    const { data: { changes, experiences, profile } } = optimization_api_schemas_.ExperienceResponse.parse(await response.json());
+                    const data = {
+                        changes,
+                        personalizations: experiences,
+                        profile
+                    };
+                    logger.debug(`"${requestName}" request successfully completed`);
+                    return data;
+                } catch (error) {
+                    this.logRequestError(error, {
+                        requestName
+                    });
+                    throw error;
+                }
+            }
+            async updateProfile({ profileId, events }, options = {}) {
+                if (!profileId) throw new Error('Valid profile ID required.');
+                const requestName = 'Update Profile';
+                logger.info(`Sending "${requestName}" request`);
+                const body = {
+                    events: optimization_api_schemas_.ExperienceEventArray.parse(events),
+                    options: this.constructBodyOptions(options)
+                };
+                logger.debug(`"${requestName}" request body:`, body);
+                try {
+                    const response = await this.makeProfileMutationRequest({
+                        url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${profileId}`,
+                        body,
+                        options
+                    });
+                    const { data: { changes, experiences, profile } } = optimization_api_schemas_.ExperienceResponse.parse(await response.json());
+                    const data = {
+                        changes,
+                        personalizations: experiences,
+                        profile
+                    };
+                    logger.debug(`"${requestName}" request successfully completed`);
+                    return data;
+                } catch (error) {
+                    this.logRequestError(error, {
+                        requestName
+                    });
+                    throw error;
+                }
+            }
+            async upsertProfile({ profileId, events }, options) {
+                if (!profileId) return await this.createProfile({
+                    events
+                }, options);
+                return await this.updateProfile({
+                    profileId,
+                    events
+                }, options);
+            }
+            async upsertManyProfiles({ events }, options = {}) {
+                const requestName = 'Upsert Many Profiles';
+                logger.info(`Sending "${requestName}" request`);
+                const body = {
+                    events: optimization_api_schemas_.ExperienceEventArray.parse(events),
+                    options: this.constructBodyOptions(options)
+                };
+                logger.debug(`"${requestName}" request body:`, body);
+                try {
+                    const response = await this.makeProfileMutationRequest({
+                        url: `v2/organizations/${this.clientId}/environments/${this.environment}/events`,
+                        body,
+                        options: {
+                            plainText: false,
+                            ...options
+                        }
+                    });
+                    const { data: { profiles } } = optimization_api_schemas_.BatchExperienceResponse.parse(await response.json());
+                    logger.debug(`"${requestName}" request successfully completed`);
+                    return profiles;
+                } catch (error) {
+                    this.logRequestError(error, {
+                        requestName
+                    });
+                    throw error;
+                }
+            }
+            constructUrl(path, options) {
+                const url = new URL(path, this.baseUrl);
+                const locale = options.locale ?? this.locale;
+                const preflight = options.preflight ?? this.preflight;
+                if (locale) url.searchParams.set('locale', locale);
+                if (preflight) url.searchParams.set('type', 'preflight');
+                return url.toString();
+            }
+            constructHeaders({ ip = this.ip, plainText = this.plainText }) {
+                const headers = new Map();
+                if (ip) headers.set('X-Force-IP', ip);
+                if (plainText ?? this.plainText ?? true) headers.set('Content-Type', 'text/plain');
+                else headers.set('Content-Type', 'application/json');
+                return Object.fromEntries(headers);
+            }
+            constructBodyOptions = ({ enabledFeatures = this.enabledFeatures })=>{
+                const bodyOptions = {};
+                if (enabledFeatures && Array.isArray(enabledFeatures) && enabledFeatures.length > 0) bodyOptions.features = enabledFeatures;
+                else bodyOptions.features = [
+                    'ip-enrichment',
+                    'location'
+                ];
+                return bodyOptions;
+            };
+        }
+        const experience = ExperienceApiClient;
+    },
+    "./src/insights/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Q: ()=>INSIGHTS_BASE_URL,
+            A: ()=>insights
+        });
+        var optimization_api_schemas_ = __webpack_require__("@contentful/optimization-api-schemas");
+        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
+        var ApiClientBase = __webpack_require__("./src/ApiClientBase.ts");
+        const logger = (0, dist.zP)('ApiClient:Insights');
+        const INSIGHTS_BASE_URL = 'https://ingest.insights.ninetailed.co/';
+        class InsightsApiClient extends ApiClientBase.A {
+            baseUrl;
+            beaconHandler;
+            constructor(config){
+                super('Insights', config);
+                const { baseUrl, beaconHandler } = config;
+                this.baseUrl = baseUrl ?? INSIGHTS_BASE_URL;
+                this.beaconHandler = beaconHandler;
+            }
+            async sendBatchEvents(batches, options = {}) {
+                const { beaconHandler = this.beaconHandler } = options;
+                const url = new URL(`v1/organizations/${this.clientId}/environments/${this.environment}/events`, this.baseUrl);
+                const body = optimization_api_schemas_.BatchInsightsEventArray.parse(batches);
+                if ('function' == typeof beaconHandler) {
+                    logger.debug('Queueing events via beaconHandler');
+                    const beaconSuccessfullyQueued = beaconHandler(url, body);
+                    if (beaconSuccessfullyQueued) return true;
+                    logger.warn('beaconHandler failed to queue events; events will be emitted immediately via fetch');
+                }
+                const requestName = 'Event Batches';
+                logger.info(`Sending "${requestName}" request`);
+                logger.debug(`"${requestName}" request body:`, body);
+                try {
+                    await this.fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify(body),
+                        keepalive: true
+                    });
+                    logger.debug(`"${requestName}" request successfully completed`);
+                    return true;
+                } catch (error) {
+                    this.logRequestError(error, {
+                        requestName
+                    });
+                    return false;
+                }
+            }
+        }
+        const insights = InsightsApiClient;
+    },
+    "@contentful/optimization-api-schemas" (module) {
+        module.exports = require("@contentful/optimization-api-schemas");
+    },
+    "../../lib/logger/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            zP: ()=>createScopedLogger
+        });
+        const external_diary_namespaceObject = require("diary");
+        require("diary/utils");
+        class Logger {
+            name = '@contentful/optimization';
+            PREFIX_PARTS = [
+                'Ctfl',
+                'O10n'
+            ];
+            DELIMITER = ':';
+            diary;
+            sinks = [];
+            constructor(){
+                this.diary = (0, external_diary_namespaceObject.diary)(this.name, this.onLogEvent.bind(this));
+                (0, external_diary_namespaceObject.enable)(this.name);
+            }
+            assembleLocationPrefix(logLocation) {
+                return `[${[
+                    ...this.PREFIX_PARTS,
+                    logLocation
+                ].join(this.DELIMITER)}]`;
+            }
+            addSink(sink) {
+                this.sinks = [
+                    ...this.sinks.filter((existingSink)=>existingSink.name !== sink.name),
+                    sink
+                ];
+            }
+            removeSink(name) {
+                this.sinks = this.sinks.filter((sink)=>sink.name !== name);
+            }
+            removeSinks() {
+                this.sinks = [];
+            }
+            debug(logLocation, message, ...args) {
+                this.diary.debug(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            info(logLocation, message, ...args) {
+                this.diary.info(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            log(logLocation, message, ...args) {
+                this.diary.log(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            warn(logLocation, message, ...args) {
+                this.diary.warn(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            error(logLocation, message, ...args) {
+                this.diary.error(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            fatal(logLocation, message, ...args) {
+                this.diary.fatal(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            onLogEvent(event) {
+                this.sinks.forEach((sink)=>{
+                    sink.ingest(event);
+                });
+            }
+        }
+        const logger = new Logger();
+        function createScopedLogger(location) {
+            return {
+                debug: (message, ...args)=>{
+                    logger.debug(location, message, ...args);
+                },
+                info: (message, ...args)=>{
+                    logger.info(location, message, ...args);
+                },
+                log: (message, ...args)=>{
+                    logger.log(location, message, ...args);
+                },
+                warn: (message, ...args)=>{
+                    logger.warn(location, message, ...args);
+                },
+                error: (message, ...args)=>{
+                    logger.error(location, message, ...args);
+                },
+                fatal: (message, ...args)=>{
+                    logger.fatal(location, message, ...args);
+                }
+            };
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        ApiClient: ()=>_ApiClient__rspack_import_0.A,
+        DEFAULT_PAGE_PROPERTIES: ()=>_builders__rspack_import_3.c,
+        EXPERIENCE_BASE_URL: ()=>_experience__rspack_import_4.n,
+        EventBuilder: ()=>_builders__rspack_import_3.e,
+        INSIGHTS_BASE_URL: ()=>_insights__rspack_import_5.Q
+    });
+    var _ApiClient__rspack_import_0 = __webpack_require__("./src/ApiClient.ts");
+    var _contentful_optimization_api_schemas__rspack_import_1 = __webpack_require__("@contentful/optimization-api-schemas");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _contentful_optimization_api_schemas__rspack_import_1)if ([
+        "default",
+        "ApiClient"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_contentful_optimization_api_schemas__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    __webpack_require__("./src/ApiClientBase.ts");
+    var _builders__rspack_import_3 = __webpack_require__("./src/builders/index.ts");
+    var _experience__rspack_import_4 = __webpack_require__("./src/experience/index.ts");
+    var _insights__rspack_import_5 = __webpack_require__("./src/insights/index.ts");
+})();
+exports.ApiClient = __webpack_exports__.ApiClient;
+exports.DEFAULT_PAGE_PROPERTIES = __webpack_exports__.DEFAULT_PAGE_PROPERTIES;
+exports.EXPERIENCE_BASE_URL = __webpack_exports__.EXPERIENCE_BASE_URL;
+exports.EventBuilder = __webpack_exports__.EventBuilder;
+exports.INSIGHTS_BASE_URL = __webpack_exports__.INSIGHTS_BASE_URL;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ApiClient",
+    "DEFAULT_PAGE_PROPERTIES",
+    "EXPERIENCE_BASE_URL",
+    "EventBuilder",
+    "INSIGHTS_BASE_URL"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map