@contentful/optimization-api-client 1.1.1 → 2.0.0

package/dist/api-schemas.cjs

@@ -1,19 +1,5 @@
 "use strict";
-var __webpack_modules__ = {
-    "@contentful/optimization-api-schemas" (module) {
-        module.exports = require("@contentful/optimization-api-schemas");
-    }
-};
-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;
-}
+var __webpack_require__ = {};
 (()=>{
     __webpack_require__.n = (module)=>{
         var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
@@ -24,11 +10,15 @@ function __webpack_require__(moduleId) {
     };
 })();
 (()=>{
-    __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__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -45,14 +35,500 @@ function __webpack_require__(moduleId) {
     };
 })();
 var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    var _contentful_optimization_api_schemas__rspack_import_0 = __webpack_require__("@contentful/optimization-api-schemas");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _contentful_optimization_api_schemas__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_contentful_optimization_api_schemas__rspack_import_0[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-})();
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    App: ()=>App,
+    BatchExperienceEvent: ()=>BatchExperienceEvent,
+    BatchExperienceEventArray: ()=>BatchExperienceEventArray,
+    BatchExperienceRequestData: ()=>BatchExperienceRequestData,
+    BatchExperienceResponse: ()=>BatchExperienceResponse,
+    BatchExperienceResponseData: ()=>BatchExperienceResponseData,
+    BatchInsightsEvent: ()=>BatchInsightsEvent,
+    BatchInsightsEventArray: ()=>BatchInsightsEventArray,
+    Campaign: ()=>Campaign,
+    Change: ()=>Change,
+    ChangeArray: ()=>ChangeArray,
+    ChangeBase: ()=>ChangeBase,
+    ChangeType: ()=>ChangeType,
+    Channel: ()=>Channel,
+    ClickEvent: ()=>ClickEvent,
+    Dictionary: ()=>Dictionary,
+    EntityChangeBase: ()=>EntityChangeBase,
+    ExoClickEvent: ()=>ExoClickEvent,
+    ExoEntityKind: ()=>ExoEntityKind,
+    ExoEventProperties: ()=>ExoEventProperties,
+    ExoHoverEvent: ()=>ExoHoverEvent,
+    ExoViewEvent: ()=>ExoViewEvent,
+    ExperienceChange: ()=>ExperienceChange,
+    ExperienceData: ()=>ExperienceData,
+    ExperienceEvent: ()=>ExperienceEvent,
+    ExperienceEventArray: ()=>ExperienceEventArray,
+    ExperienceRequestData: ()=>ExperienceRequestData,
+    ExperienceRequestOptions: ()=>ExperienceRequestOptions,
+    ExperienceResponse: ()=>ExperienceResponse,
+    FragmentChange: ()=>FragmentChange,
+    GeoLocation: ()=>GeoLocation,
+    HoverEvent: ()=>HoverEvent,
+    IdentifyEvent: ()=>IdentifyEvent,
+    InsightsEvent: ()=>InsightsEvent,
+    InsightsEventArray: ()=>InsightsEventArray,
+    InteractionEventProperties: ()=>InteractionEventProperties,
+    Library: ()=>Library,
+    Page: ()=>Page,
+    PageEventContext: ()=>PageEventContext,
+    PageViewEvent: ()=>PageViewEvent,
+    PartialProfile: ()=>PartialProfile,
+    Profile: ()=>Profile,
+    Properties: ()=>Properties,
+    ResponseEnvelope: ()=>ResponseEnvelope,
+    Screen: ()=>Screen,
+    ScreenEventContext: ()=>ScreenEventContext,
+    ScreenViewEvent: ()=>ScreenViewEvent,
+    SelectedOptimization: ()=>SelectedOptimization,
+    SelectedOptimizationArray: ()=>SelectedOptimizationArray,
+    SessionStatistics: ()=>SessionStatistics,
+    TrackEvent: ()=>TrackEvent,
+    Traits: ()=>Traits,
+    UniversalEventContext: ()=>UniversalEventContext,
+    UniversalEventProperties: ()=>UniversalEventProperties,
+    UnknownChange: ()=>UnknownChange,
+    VariableChange: ()=>VariableChange,
+    VariableChangeValue: ()=>VariableChangeValue,
+    ViewEvent: ()=>ViewEvent,
+    isVariableChange: ()=>isVariableChange,
+    parseWithFriendlyError: ()=>parseWithFriendlyError
+});
+const mini_namespaceObject = require("zod/mini");
+const App = mini_namespaceObject.optional(mini_namespaceObject.object({
+    name: mini_namespaceObject.string(),
+    version: mini_namespaceObject.string()
+}));
+const Campaign = mini_namespaceObject.object({
+    name: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    source: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    medium: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    term: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    content: mini_namespaceObject.optional(mini_namespaceObject.string())
+});
+const Channel = mini_namespaceObject.union([
+    mini_namespaceObject.literal('mobile'),
+    mini_namespaceObject.literal('server'),
+    mini_namespaceObject.literal('web')
+]);
+const Dictionary = mini_namespaceObject.record(mini_namespaceObject.string(), mini_namespaceObject.string());
+const COUNTRY_CODE_LENGTH = 2;
+const Coordinates = mini_namespaceObject.object({
+    latitude: mini_namespaceObject.number(),
+    longitude: mini_namespaceObject.number()
+});
+const GeoLocation = mini_namespaceObject.object({
+    coordinates: mini_namespaceObject.optional(Coordinates),
+    city: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    postalCode: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    region: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    regionCode: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    country: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    countryCode: mini_namespaceObject.optional(mini_namespaceObject.string().check(mini_namespaceObject.length(COUNTRY_CODE_LENGTH))),
+    continent: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    timezone: mini_namespaceObject.optional(mini_namespaceObject.string())
+});
+const Library = mini_namespaceObject.object({
+    name: mini_namespaceObject.string(),
+    version: mini_namespaceObject.string()
+});
+const Page = mini_namespaceObject.catchall(mini_namespaceObject.object({
+    path: mini_namespaceObject.string(),
+    query: Dictionary,
+    referrer: mini_namespaceObject.string(),
+    search: mini_namespaceObject.string(),
+    title: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    url: mini_namespaceObject.string()
+}), mini_namespaceObject.json());
+const Properties = mini_namespaceObject.record(mini_namespaceObject.string(), mini_namespaceObject.json());
+const Screen = mini_namespaceObject.catchall(mini_namespaceObject.object({
+    name: mini_namespaceObject.string()
+}), mini_namespaceObject.json());
+const Traits = mini_namespaceObject.record(mini_namespaceObject.string(), mini_namespaceObject.json());
+const UniversalEventContext = mini_namespaceObject.object({
+    app: App,
+    campaign: Campaign,
+    gdpr: mini_namespaceObject.object({
+        isConsentGiven: mini_namespaceObject.boolean()
+    }),
+    library: Library,
+    locale: mini_namespaceObject.string(),
+    location: mini_namespaceObject.optional(GeoLocation),
+    userAgent: mini_namespaceObject.optional(mini_namespaceObject.string())
+});
+const UniversalEventProperties = mini_namespaceObject.object({
+    channel: Channel,
+    context: mini_namespaceObject.extend(UniversalEventContext, {
+        page: mini_namespaceObject.optional(Page),
+        screen: mini_namespaceObject.optional(Screen)
+    }),
+    messageId: mini_namespaceObject.string(),
+    originalTimestamp: mini_namespaceObject.iso.datetime(),
+    sentAt: mini_namespaceObject.iso.datetime(),
+    timestamp: mini_namespaceObject.iso.datetime(),
+    userId: mini_namespaceObject.optional(mini_namespaceObject.string())
+});
+const ExoEntityKind = mini_namespaceObject["enum"]([
+    'Experience',
+    'Fragment',
+    'InlineFragment',
+    'InlineComponent'
+]);
+const ExoEventProperties = mini_namespaceObject.extend(UniversalEventProperties, {
+    entityId: mini_namespaceObject.string(),
+    entityKind: ExoEntityKind,
+    entityKindId: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    entryIds: mini_namespaceObject.optional(mini_namespaceObject.array(mini_namespaceObject.string())),
+    optimizationId: mini_namespaceObject.string(),
+    parameters: mini_namespaceObject.optional(mini_namespaceObject.record(mini_namespaceObject.string(), mini_namespaceObject.json())),
+    parentExperienceId: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    variantId: mini_namespaceObject.string(),
+    variantIndex: mini_namespaceObject.optional(mini_namespaceObject.number())
+});
+const ExoViewEvent = mini_namespaceObject.extend(ExoEventProperties, {
+    type: mini_namespaceObject.literal('exo_node_view'),
+    viewDurationMs: mini_namespaceObject.int().check(mini_namespaceObject.minimum(0)),
+    viewId: mini_namespaceObject.string()
+});
+const IdentifyEvent = mini_namespaceObject.extend(UniversalEventProperties, {
+    type: mini_namespaceObject.literal('identify'),
+    traits: Traits
+});
+const PageEventContext = mini_namespaceObject.extend(UniversalEventContext, {
+    page: Page
+});
+const PageViewEvent = mini_namespaceObject.extend(UniversalEventProperties, {
+    type: mini_namespaceObject.literal('page'),
+    name: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    properties: Page,
+    context: PageEventContext
+});
+const ScreenEventContext = mini_namespaceObject.extend(UniversalEventContext, {
+    screen: Screen
+});
+const ScreenViewEvent = mini_namespaceObject.extend(UniversalEventProperties, {
+    type: mini_namespaceObject.literal('screen'),
+    name: mini_namespaceObject.string(),
+    properties: mini_namespaceObject.optional(Properties),
+    context: ScreenEventContext
+});
+const TrackEvent = mini_namespaceObject.extend(UniversalEventProperties, {
+    type: mini_namespaceObject.literal('track'),
+    event: mini_namespaceObject.string(),
+    properties: Properties
+});
+const InteractionEventProperties = mini_namespaceObject.extend(UniversalEventProperties, {
+    componentType: mini_namespaceObject.union([
+        mini_namespaceObject.literal('Entry'),
+        mini_namespaceObject.literal('Variable')
+    ]),
+    componentId: mini_namespaceObject.string(),
+    experienceId: mini_namespaceObject.optional(mini_namespaceObject.string()),
+    variantIndex: mini_namespaceObject.number()
+});
+const ViewEvent = mini_namespaceObject.extend(InteractionEventProperties, {
+    type: mini_namespaceObject.literal('component'),
+    viewDurationMs: mini_namespaceObject.optional(mini_namespaceObject.number()),
+    viewId: mini_namespaceObject.optional(mini_namespaceObject.string())
+});
+const Anon = {
+    anonymousId: mini_namespaceObject.string()
+};
+const BatchExperienceEvent = mini_namespaceObject.discriminatedUnion('type', [
+    mini_namespaceObject.extend(ViewEvent, Anon),
+    mini_namespaceObject.extend(ExoViewEvent, Anon),
+    mini_namespaceObject.extend(IdentifyEvent, Anon),
+    mini_namespaceObject.extend(PageViewEvent, Anon),
+    mini_namespaceObject.extend(ScreenViewEvent, Anon),
+    mini_namespaceObject.extend(TrackEvent, Anon)
+]);
+const BatchExperienceEventArray = mini_namespaceObject.array(BatchExperienceEvent);
+const ExperienceEvent = mini_namespaceObject.discriminatedUnion('type', [
+    ViewEvent,
+    ExoViewEvent,
+    IdentifyEvent,
+    PageViewEvent,
+    ScreenViewEvent,
+    TrackEvent
+]);
+const ExperienceEventArray = mini_namespaceObject.array(ExperienceEvent);
+const ExperienceRequestOptions = mini_namespaceObject.object({
+    features: mini_namespaceObject.optional(mini_namespaceObject.array(mini_namespaceObject.string()))
+});
+const ExperienceRequestData = mini_namespaceObject.object({
+    events: ExperienceEventArray.check(mini_namespaceObject.minLength(1)),
+    options: mini_namespaceObject.optional(ExperienceRequestOptions)
+});
+const BatchExperienceRequestData = mini_namespaceObject.object({
+    events: BatchExperienceEventArray.check(mini_namespaceObject.minLength(1)),
+    options: mini_namespaceObject.optional(ExperienceRequestOptions)
+});
+const SessionStatistics = mini_namespaceObject.object({
+    id: mini_namespaceObject.string(),
+    isReturningVisitor: mini_namespaceObject.boolean(),
+    landingPage: Page,
+    count: mini_namespaceObject.number(),
+    activeSessionLength: mini_namespaceObject.number(),
+    averageSessionLength: mini_namespaceObject.number()
+});
+const Profile = mini_namespaceObject.object({
+    id: mini_namespaceObject.string(),
+    stableId: mini_namespaceObject.string(),
+    random: mini_namespaceObject.number(),
+    audiences: mini_namespaceObject.array(mini_namespaceObject.string()),
+    traits: Traits,
+    location: GeoLocation,
+    session: SessionStatistics
+});
+const PartialProfile = mini_namespaceObject.catchall(mini_namespaceObject.object({
+    id: mini_namespaceObject.string()
+}), mini_namespaceObject.json());
+const ResponseEnvelope = mini_namespaceObject.object({
+    data: mini_namespaceObject.object(),
+    message: mini_namespaceObject.string(),
+    error: mini_namespaceObject.nullable(mini_namespaceObject.object({
+        code: mini_namespaceObject.string()
+    }))
+});
+const BatchExperienceResponseData = mini_namespaceObject.object({
+    profiles: mini_namespaceObject.optional(mini_namespaceObject.array(Profile))
+});
+const BatchExperienceResponse = mini_namespaceObject.extend(ResponseEnvelope, {
+    data: BatchExperienceResponseData
+});
+const ChangeType = [
+    'Variable',
+    'Experience',
+    'Fragment'
+];
+const ChangeBase = mini_namespaceObject.object({
+    key: mini_namespaceObject.string(),
+    type: mini_namespaceObject.union([
+        mini_namespaceObject["enum"](ChangeType),
+        mini_namespaceObject.string()
+    ]),
+    meta: mini_namespaceObject.object({
+        experienceId: mini_namespaceObject.string(),
+        variantIndex: mini_namespaceObject.number()
+    })
+});
+const VariableChangeValue = mini_namespaceObject.union([
+    mini_namespaceObject.string(),
+    mini_namespaceObject.boolean(),
+    mini_namespaceObject["null"](),
+    mini_namespaceObject.number(),
+    mini_namespaceObject.record(mini_namespaceObject.string(), mini_namespaceObject.json())
+]);
+const UnknownChange = mini_namespaceObject.extend(ChangeBase, {
+    type: mini_namespaceObject.string(),
+    value: mini_namespaceObject.unknown()
+});
+const VariableChange = mini_namespaceObject.extend(ChangeBase, {
+    type: mini_namespaceObject.literal('Variable'),
+    value: VariableChangeValue
+});
+const EntityChangeBase = mini_namespaceObject.object({
+    id: mini_namespaceObject.string(),
+    variantId: mini_namespaceObject.string(),
+    meta: mini_namespaceObject.object({
+        optimizationId: mini_namespaceObject.string(),
+        variantIndex: mini_namespaceObject.number()
+    })
+});
+const ExperienceChange = mini_namespaceObject.extend(EntityChangeBase, {
+    type: mini_namespaceObject.literal('Experience')
+});
+const FragmentChange = mini_namespaceObject.extend(EntityChangeBase, {
+    type: mini_namespaceObject.literal('Fragment')
+});
+const Change = mini_namespaceObject.discriminatedUnion('type', [
+    VariableChange,
+    ExperienceChange,
+    FragmentChange
+]);
+const ChangeArray = mini_namespaceObject.array(Change);
+function isVariableChange(change) {
+    return 'Variable' === change.type;
+}
+const SelectedOptimization = mini_namespaceObject.object({
+    experienceId: mini_namespaceObject.string(),
+    variantIndex: mini_namespaceObject.number(),
+    variants: mini_namespaceObject.record(mini_namespaceObject.string(), mini_namespaceObject.string()),
+    sticky: mini_namespaceObject.optional(mini_namespaceObject.prefault(mini_namespaceObject.boolean(), false))
+});
+const SelectedOptimizationArray = mini_namespaceObject.array(SelectedOptimization);
+const ExperienceData = mini_namespaceObject.object({
+    profile: Profile,
+    experiences: SelectedOptimizationArray,
+    changes: ChangeArray
+});
+const ExperienceResponse = mini_namespaceObject.extend(ResponseEnvelope, {
+    data: ExperienceData
+});
+const ClickEvent = mini_namespaceObject.extend(InteractionEventProperties, {
+    type: mini_namespaceObject.literal('component_click')
+});
+const ExoClickEvent = mini_namespaceObject.extend(ExoEventProperties, {
+    type: mini_namespaceObject.literal('exo_node_click')
+});
+const ExoHoverEvent = mini_namespaceObject.extend(ExoEventProperties, {
+    type: mini_namespaceObject.literal('exo_node_hover'),
+    hoverDurationMs: mini_namespaceObject.int().check(mini_namespaceObject.minimum(0)),
+    hoverId: mini_namespaceObject.string()
+});
+const HoverEvent = mini_namespaceObject.extend(InteractionEventProperties, {
+    type: mini_namespaceObject.literal('component_hover'),
+    hoverDurationMs: mini_namespaceObject.number(),
+    hoverId: mini_namespaceObject.string()
+});
+const InsightsEvent = mini_namespaceObject.discriminatedUnion('type', [
+    ViewEvent,
+    ClickEvent,
+    HoverEvent,
+    ExoViewEvent,
+    ExoClickEvent,
+    ExoHoverEvent
+]);
+const InsightsEventArray = mini_namespaceObject.array(InsightsEvent);
+const BatchInsightsEvent = mini_namespaceObject.object({
+    profile: PartialProfile,
+    events: InsightsEventArray
+});
+const BatchInsightsEventArray = mini_namespaceObject.array(BatchInsightsEvent);
+const en_js_namespaceObject = require("zod/v4/locales/en.js");
+var en_js_default = /*#__PURE__*/ __webpack_require__.n(en_js_namespaceObject);
+mini_namespaceObject.config(en_js_default()());
+function parseWithFriendlyError(schema, data) {
+    const result = schema.safeParse(data);
+    if (result.success) return result.data;
+    throw new Error(mini_namespaceObject.prettifyError(result.error));
+}
+exports.App = __webpack_exports__.App;
+exports.BatchExperienceEvent = __webpack_exports__.BatchExperienceEvent;
+exports.BatchExperienceEventArray = __webpack_exports__.BatchExperienceEventArray;
+exports.BatchExperienceRequestData = __webpack_exports__.BatchExperienceRequestData;
+exports.BatchExperienceResponse = __webpack_exports__.BatchExperienceResponse;
+exports.BatchExperienceResponseData = __webpack_exports__.BatchExperienceResponseData;
+exports.BatchInsightsEvent = __webpack_exports__.BatchInsightsEvent;
+exports.BatchInsightsEventArray = __webpack_exports__.BatchInsightsEventArray;
+exports.Campaign = __webpack_exports__.Campaign;
+exports.Change = __webpack_exports__.Change;
+exports.ChangeArray = __webpack_exports__.ChangeArray;
+exports.ChangeBase = __webpack_exports__.ChangeBase;
+exports.ChangeType = __webpack_exports__.ChangeType;
+exports.Channel = __webpack_exports__.Channel;
+exports.ClickEvent = __webpack_exports__.ClickEvent;
+exports.Dictionary = __webpack_exports__.Dictionary;
+exports.EntityChangeBase = __webpack_exports__.EntityChangeBase;
+exports.ExoClickEvent = __webpack_exports__.ExoClickEvent;
+exports.ExoEntityKind = __webpack_exports__.ExoEntityKind;
+exports.ExoEventProperties = __webpack_exports__.ExoEventProperties;
+exports.ExoHoverEvent = __webpack_exports__.ExoHoverEvent;
+exports.ExoViewEvent = __webpack_exports__.ExoViewEvent;
+exports.ExperienceChange = __webpack_exports__.ExperienceChange;
+exports.ExperienceData = __webpack_exports__.ExperienceData;
+exports.ExperienceEvent = __webpack_exports__.ExperienceEvent;
+exports.ExperienceEventArray = __webpack_exports__.ExperienceEventArray;
+exports.ExperienceRequestData = __webpack_exports__.ExperienceRequestData;
+exports.ExperienceRequestOptions = __webpack_exports__.ExperienceRequestOptions;
+exports.ExperienceResponse = __webpack_exports__.ExperienceResponse;
+exports.FragmentChange = __webpack_exports__.FragmentChange;
+exports.GeoLocation = __webpack_exports__.GeoLocation;
+exports.HoverEvent = __webpack_exports__.HoverEvent;
+exports.IdentifyEvent = __webpack_exports__.IdentifyEvent;
+exports.InsightsEvent = __webpack_exports__.InsightsEvent;
+exports.InsightsEventArray = __webpack_exports__.InsightsEventArray;
+exports.InteractionEventProperties = __webpack_exports__.InteractionEventProperties;
+exports.Library = __webpack_exports__.Library;
+exports.Page = __webpack_exports__.Page;
+exports.PageEventContext = __webpack_exports__.PageEventContext;
+exports.PageViewEvent = __webpack_exports__.PageViewEvent;
+exports.PartialProfile = __webpack_exports__.PartialProfile;
+exports.Profile = __webpack_exports__.Profile;
+exports.Properties = __webpack_exports__.Properties;
+exports.ResponseEnvelope = __webpack_exports__.ResponseEnvelope;
+exports.Screen = __webpack_exports__.Screen;
+exports.ScreenEventContext = __webpack_exports__.ScreenEventContext;
+exports.ScreenViewEvent = __webpack_exports__.ScreenViewEvent;
+exports.SelectedOptimization = __webpack_exports__.SelectedOptimization;
+exports.SelectedOptimizationArray = __webpack_exports__.SelectedOptimizationArray;
+exports.SessionStatistics = __webpack_exports__.SessionStatistics;
+exports.TrackEvent = __webpack_exports__.TrackEvent;
+exports.Traits = __webpack_exports__.Traits;
+exports.UniversalEventContext = __webpack_exports__.UniversalEventContext;
+exports.UniversalEventProperties = __webpack_exports__.UniversalEventProperties;
+exports.UnknownChange = __webpack_exports__.UnknownChange;
+exports.VariableChange = __webpack_exports__.VariableChange;
+exports.VariableChangeValue = __webpack_exports__.VariableChangeValue;
+exports.ViewEvent = __webpack_exports__.ViewEvent;
+exports.isVariableChange = __webpack_exports__.isVariableChange;
+exports.parseWithFriendlyError = __webpack_exports__.parseWithFriendlyError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "App",
+    "BatchExperienceEvent",
+    "BatchExperienceEventArray",
+    "BatchExperienceRequestData",
+    "BatchExperienceResponse",
+    "BatchExperienceResponseData",
+    "BatchInsightsEvent",
+    "BatchInsightsEventArray",
+    "Campaign",
+    "Change",
+    "ChangeArray",
+    "ChangeBase",
+    "ChangeType",
+    "Channel",
+    "ClickEvent",
+    "Dictionary",
+    "EntityChangeBase",
+    "ExoClickEvent",
+    "ExoEntityKind",
+    "ExoEventProperties",
+    "ExoHoverEvent",
+    "ExoViewEvent",
+    "ExperienceChange",
+    "ExperienceData",
+    "ExperienceEvent",
+    "ExperienceEventArray",
+    "ExperienceRequestData",
+    "ExperienceRequestOptions",
+    "ExperienceResponse",
+    "FragmentChange",
+    "GeoLocation",
+    "HoverEvent",
+    "IdentifyEvent",
+    "InsightsEvent",
+    "InsightsEventArray",
+    "InteractionEventProperties",
+    "Library",
+    "Page",
+    "PageEventContext",
+    "PageViewEvent",
+    "PartialProfile",
+    "Profile",
+    "Properties",
+    "ResponseEnvelope",
+    "Screen",
+    "ScreenEventContext",
+    "ScreenViewEvent",
+    "SelectedOptimization",
+    "SelectedOptimizationArray",
+    "SessionStatistics",
+    "TrackEvent",
+    "Traits",
+    "UniversalEventContext",
+    "UniversalEventProperties",
+    "UnknownChange",
+    "VariableChange",
+    "VariableChangeValue",
+    "ViewEvent",
+    "isVariableChange",
+    "parseWithFriendlyError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });