@convertcom/js-sdk-rules 2.0.0 → 2.1.0

package/lib/types/src/config/models/ConfigExperience.d.ts

@@ -0,0 +1,98 @@
+import type { ExperienceIntegrationBaidu } from './ExperienceIntegrationBaidu';
+import type { ExperienceIntegrationClicktale } from './ExperienceIntegrationClicktale';
+import type { ExperienceIntegrationClicky } from './ExperienceIntegrationClicky';
+import type { ExperienceIntegrationCnzz } from './ExperienceIntegrationCnzz';
+import type { ExperienceIntegrationCrazyegg } from './ExperienceIntegrationCrazyegg';
+import type { ExperienceIntegrationEconda } from './ExperienceIntegrationEconda';
+import type { ExperienceIntegrationEulerian } from './ExperienceIntegrationEulerian';
+import type { ExperienceIntegrationGAServing } from './ExperienceIntegrationGAServing';
+import type { ExperienceIntegrationGosquared } from './ExperienceIntegrationGosquared';
+import type { ExperienceIntegrationHeapanalytics } from './ExperienceIntegrationHeapanalytics';
+import type { ExperienceIntegrationHotjar } from './ExperienceIntegrationHotjar';
+import type { ExperienceIntegrationMixpanel } from './ExperienceIntegrationMixpanel';
+import type { ExperienceIntegrationMouseflow } from './ExperienceIntegrationMouseflow';
+import type { ExperienceIntegrationPiwik } from './ExperienceIntegrationPiwik';
+import type { ExperienceIntegrationSegmentio } from './ExperienceIntegrationSegmentio';
+import type { ExperienceIntegrationSitecatalyst } from './ExperienceIntegrationSitecatalyst';
+import type { ExperienceIntegrationWoopra } from './ExperienceIntegrationWoopra';
+import type { ExperienceIntegrationYsance } from './ExperienceIntegrationYsance';
+import type { ExperienceTypes } from './ExperienceTypes';
+import type { ExperienceVariationConfig } from './ExperienceVariationConfig';
+import type { RuleObject } from './RuleObject';
+export type ConfigExperience = {
+    /**
+     * Experience ID
+     */
+    id?: string;
+    /**
+     * Experience Name
+     */
+    name?: string;
+    /**
+     * Experience readable key that uniquely identifies this experience
+     */
+    key?: string;
+    /**
+     * List of locations IDs on which this experience is presented. Either this or **site_area** is given but should not be both.
+     */
+    locations?: Array<string> | null;
+    /**
+     * Rules that define where the experience is gonna run. Either this or **locations** is given but should not be both.
+     */
+    site_area?: RuleObject | null;
+    /**
+     * List of audiences IDs to which this experience is presented to
+     */
+    audiences?: Array<string> | null;
+    /**
+     * List of goals IDs to which will be tracked for this experience
+     */
+    goals?: Array<string>;
+    /**
+     * Global Experience's JavaScript that will run for this experience before its changes are applied
+     *
+     */
+    global_js?: string;
+    /**
+     * Global Experience's StyleSheet that will run for this experience before its changes are applied
+     *
+     */
+    global_css?: string;
+    type?: ExperienceTypes;
+    /**
+     * Experience's version number
+     */
+    version?: number;
+    /**
+     * Experience's variations list
+     */
+    variations?: Array<ExperienceVariationConfig>;
+    /**
+     * List of integrations that this experience's data is sent to
+     */
+    integrations?: Array<(ExperienceIntegrationBaidu | ExperienceIntegrationClicktale | ExperienceIntegrationClicky | ExperienceIntegrationCnzz | ExperienceIntegrationCrazyegg | ExperienceIntegrationEconda | ExperienceIntegrationEulerian | ExperienceIntegrationGAServing | ExperienceIntegrationGosquared | ExperienceIntegrationHeapanalytics | ExperienceIntegrationHotjar | ExperienceIntegrationMixpanel | ExperienceIntegrationMouseflow | ExperienceIntegrationPiwik | ExperienceIntegrationSegmentio | ExperienceIntegrationSitecatalyst | ExperienceIntegrationWoopra | ExperienceIntegrationYsance)>;
+    /**
+     * List of environments that this experience is supposed to run on. The full list of available environments is defined at
+     * project level. If this list is empty, the experience will run on all environments.
+     *
+     * @deprecated
+     */
+    environments?: Array<string>;
+    /**
+     * The environment where this experience will run. It has to be one of the environments defined at the project level
+     */
+    environment?: string;
+    /**
+     * Various experience's settings
+     */
+    settings?: {
+        /**
+         * Minimum order value for transactions outliers
+         */
+        min_order_value?: number;
+        /**
+         * Maximum order value for transactions outliers
+         */
+        max_order_value?: number;
+    };
+};

package/lib/types/src/config/models/ConfigFeature.d.ts

@@ -0,0 +1,22 @@
+import type { FeatureVariableItemData } from './FeatureVariableItemData';
+/**
+ * Base Feature Object
+ */
+export type ConfigFeature = {
+    /**
+     * Feature ID
+     */
+    id?: string;
+    /**
+     * A name given to the feature to identify it easily
+     */
+    name?: string;
+    /**
+     * A unique per project level identifier
+     */
+    key?: string;
+    /**
+     * An array of user-defined variables of a feature.
+     */
+    variables?: Array<FeatureVariableItemData>;
+};

package/lib/types/src/config/models/ConfigGoal.d.ts

@@ -0,0 +1,9 @@
+import type { ClicksElementGoal } from './ClicksElementGoal';
+import type { ClicksLinkGoal } from './ClicksLinkGoal';
+import type { DomInteractionGoal } from './DomInteractionGoal';
+import type { GaGoal } from './GaGoal';
+import type { NoSettingsGoal } from './NoSettingsGoal';
+import type { RevenueGoal } from './RevenueGoal';
+import type { ScrollPercentageGoal } from './ScrollPercentageGoal';
+import type { SubmitsFormGoal } from './SubmitsFormGoal';
+export type ConfigGoal = (DomInteractionGoal | ScrollPercentageGoal | RevenueGoal | NoSettingsGoal | GaGoal | SubmitsFormGoal | ClicksLinkGoal | ClicksElementGoal);

package/lib/types/src/config/models/ConfigGoalBase.d.ts

@@ -0,0 +1,24 @@
+import type { GoalTypes } from './GoalTypes';
+import type { RuleObject } from './RuleObject';
+/**
+ * Goal item to be tracked  inside a project
+ */
+export type ConfigGoalBase = {
+    /**
+     * Goal ID
+     */
+    id?: string;
+    /**
+     * Goal Name.
+     */
+    name?: string;
+    /**
+     * Goal Key
+     */
+    key?: string;
+    /**
+     * List of goal types to be returned
+     */
+    type?: Array<GoalTypes>;
+    rules?: RuleObject | null;
+};

package/lib/types/src/config/models/ConfigLocation.d.ts

@@ -0,0 +1,21 @@
+import type { LocationTrigger } from './LocationTrigger';
+import type { RuleObject } from './RuleObject';
+/**
+ * Base Location object
+ */
+export type ConfigLocation = {
+    /**
+     * Location ID
+     */
+    id?: string;
+    /**
+     * Location unique key
+     */
+    key?: string;
+    /**
+     * Location Name
+     */
+    name?: string;
+    trigger?: (Record<string, any> & LocationTrigger) | null;
+    rules?: RuleObject | null;
+};

package/lib/types/src/config/models/ConfigProject.d.ts

@@ -0,0 +1,151 @@
+import type { GA_Settings } from './GA_Settings';
+import type { UTC_Offset } from './UTC_Offset';
+/**
+ * Project Object under which experiences would get created
+ */
+export type ConfigProject = {
+    /**
+     * Project ID
+     */
+    id?: string;
+    /**
+     * Project Name. If **settings.data_anonymization** is turned on, the name will be generated from **id** field
+     */
+    name?: string;
+    /**
+     * Value which describes project product type
+     */
+    type?: ConfigProject.type;
+    utc_offset?: UTC_Offset;
+    /**
+     * Object representing the custom domain that is used for loading the tracking scripts and
+     * sending tracking requests to Convert servers instead of the standard Convert domain
+     *
+     */
+    custom_domain?: {
+        /**
+         * Custom domain to be used instead of standard Convert's one
+         */
+        domain?: string;
+    } | null;
+    /**
+     * List of domains allowed to be tracked under this project
+     */
+    domains?: Array<{
+        /**
+         * Top level domain, used for setting cookies where applicable
+         */
+        tld?: string;
+        /**
+         * List of host names under **tld** which are allowed to be tracked under this project
+         */
+        hosts?: any;
+    }>;
+    /**
+     * The global javascript code that will be loaded on all pages where
+     * the tracking script is installed, prior do processing any of
+     * experiences, goals, audiences etc.
+     *
+     */
+    global_javascript?: string | null;
+    /**
+     * Various project's settings
+     */
+    settings?: {
+        /**
+         * Flag indicating whether decoration of outgoing links (appending tracking cookies inside the link URL in order to
+         * make cross domain tracking possible) is done automatically on page
+         *
+         */
+        allow_crossdomain_tracking?: boolean;
+        /**
+         * Whether or not data is [anonymized](https://convert.zendesk.com/hc/en-us/articles/204506339-Prevent-Experiment-Details-Data-Leak-with-Data-Anonymization).
+         */
+        data_anonymization?: boolean;
+        /**
+         * Follow the 'Do not track' browser settings for users in the mentioned area of the world.
+         */
+        do_not_track?: ConfigProject.do_not_track;
+        /**
+         * Follow Global Privacy Control (GPC) signals for users in the mentioned area of the world.
+         * - OFF: Do not follow GPC signals.
+         * - EU ONLY: Follow GPC signals for users in the European Union only.
+         * - EEA ONLY: Follow GPC signals for users in the European Economic Area only.
+         * - Worldwide: Follow GPC signals for users worldwide.
+         *
+         */
+        global_privacy_control?: ConfigProject.global_privacy_control;
+        /**
+         * Whether to include jQuery library or not into the javascript tracking file served by Convert and loaded via the tracking snippet. If jQuery is not included, it has to be loaded on page, before Convert's tracking code
+         */
+        include_jquery?: boolean;
+        /**
+         * Whether to include jQuery library or not into the v1 javascript tracking file served by Convert and loaded via the tracking snippet.
+         */
+        include_jquery_v1?: boolean;
+        /**
+         * Whether to disable the SPA (Single Page Application) related functionalities from the tracking scripts V1. Most websites work fine without disabling SPA functionality regardless of the fact they are Single Page Apps or not. In edge situation, this setting might prove handy
+         */
+        disable_spa_functionality?: boolean;
+        /**
+         * When this is turned to true, Convert won't track any referral data like http referral, utm query strings etc. Those will be used on the current page if available but won't be stored in cookies in order to be used on subsequent pages.
+         */
+        do_not_track_referral?: boolean;
+        /**
+         * This holds project wide settings used by integrations
+         */
+        integrations?: {
+            google_analytics?: GA_Settings;
+            kissmetrics?: {
+                /**
+                 * Flag indicating whether Kissmetrics integration is enabled or not for this project
+                 */
+                enabled?: boolean;
+            };
+        };
+        /**
+         * Minimum order value for transactions outliers
+         */
+        min_order_value?: number;
+        /**
+         * Maximum order value for transactions outliers
+         */
+        max_order_value?: number;
+    };
+    /**
+     * A user-defined key-value object which describes environments available for the project.
+     */
+    environments?: Record<string, any>;
+};
+export declare namespace ConfigProject {
+    /**
+     * Value which describes project product type
+     */
+    enum type {
+        FULLSTACK = "fullstack",
+        WEB = "web"
+    }
+    /**
+     * Follow the 'Do not track' browser settings for users in the mentioned area of the world.
+     */
+    enum do_not_track {
+        OFF = "OFF",
+        EU_ONLY = "EU ONLY",
+        EEA_ONLY = "EEA ONLY",
+        WORLDWIDE = "Worldwide"
+    }
+    /**
+     * Follow Global Privacy Control (GPC) signals for users in the mentioned area of the world.
+     * - OFF: Do not follow GPC signals.
+     * - EU ONLY: Follow GPC signals for users in the European Union only.
+     * - EEA ONLY: Follow GPC signals for users in the European Economic Area only.
+     * - Worldwide: Follow GPC signals for users worldwide.
+     *
+     */
+    enum global_privacy_control {
+        OFF = "OFF",
+        EU_ONLY = "EU ONLY",
+        EEA_ONLY = "EEA ONLY",
+        WORLDWIDE = "Worldwide"
+    }
+}

package/lib/types/src/config/models/ConfigResponseData.d.ts

@@ -0,0 +1,45 @@
+import type { ConfigAudience } from './ConfigAudience';
+import type { ConfigExperience } from './ConfigExperience';
+import type { ConfigFeature } from './ConfigFeature';
+import type { ConfigGoal } from './ConfigGoal';
+import type { ConfigLocation } from './ConfigLocation';
+import type { ConfigProject } from './ConfigProject';
+import type { ConfigSegment } from './ConfigSegment';
+/**
+ * Response containing project's config data needed in order to serve experiences
+ */
+export type ConfigResponseData = {
+    /**
+     * Account ID under which the project exists
+     */
+    account_id?: string;
+    project?: ConfigProject;
+    /**
+     * List of goals to be tracked in the project
+     */
+    goals?: Array<ConfigGoal>;
+    /**
+     * List of locations that are used inside this project
+     */
+    locations?: Array<ConfigLocation>;
+    /**
+     * List of audiences that are used inside this project
+     */
+    audiences?: Array<ConfigAudience>;
+    /**
+     * List of custom that are devined inside this project
+     */
+    segments?: Array<ConfigSegment>;
+    /**
+     * List of active experiences inside this project
+     */
+    experiences?: Array<ConfigExperience>;
+    /**
+     * List of archived experiences inside this project, which were archived within the last 8 months
+     */
+    archived_experiences?: Array<string>;
+    /**
+     * List of features inside this project. Presented only for fullstack projects
+     */
+    features?: Array<ConfigFeature>;
+};

package/lib/types/src/config/models/ConfigSegment.d.ts

@@ -0,0 +1,19 @@
+import type { RuleObject } from './RuleObject';
+/**
+ * Base Segment object
+ */
+export type ConfigSegment = {
+    /**
+     * Segment ID
+     */
+    id?: string;
+    /**
+     * Segment unique key
+     */
+    key?: string;
+    /**
+     * Segment Name
+     */
+    name?: string;
+    rules?: RuleObject | null;
+};

package/lib/types/src/config/models/ConversionEvent.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Conversion event data
+ */
+export type ConversionEvent = {
+    /**
+     * Id of the conversion goal to be fired
+     */
+    goalId: string;
+    /**
+     * Data connected to this conversion, for non binomial metrics, eg revenue
+     */
+    goalData?: Array<{
+        /**
+         * Key of the metric
+         */
+        key?: 'amount' | 'productsCount' | 'transactionId';
+        /**
+         * Value of the metric
+         */
+        value?: (number | string);
+    }>;
+    /**
+     * Bucketing data (experiences that this visitor is currently part of) for the visitor. In case that **enrichData=true** flag is being sent and
+     * this attribute is not provided, the bucketing stored on the backend datastore for the given visitor is gonna be used. If both **enrichData=true** and
+     * **bucketingData**, the **bucketingData** is gonna be merged with the stored data inside the backend data source, the request provided data having the
+     * biggest overwriting bucketing for the same experience which might exist on the backend
+     *
+     */
+    bucketingData?: Record<string, string>;
+};

package/lib/types/src/config/models/CookieMatchRule.d.ts

@@ -0,0 +1,14 @@
+import type { BaseMatch } from './BaseMatch';
+import type { BaseRuleWithStringValue } from './BaseRuleWithStringValue';
+import type { CookieMatchRulesTypes } from './CookieMatchRulesTypes';
+import type { TextMatchingOptions } from './TextMatchingOptions';
+export type CookieMatchRule = (BaseRuleWithStringValue & {
+    rule_type: CookieMatchRulesTypes;
+    matching?: (BaseMatch & {
+        match_type?: TextMatchingOptions;
+    });
+    /**
+     * The name of the cookie which value is compared to the given rule value
+     */
+    key?: string;
+});

package/lib/types/src/config/models/CookieMatchRulesTypes.d.ts

@@ -0,0 +1,3 @@
+export declare enum CookieMatchRulesTypes {
+    COOKIE = "cookie"
+}

package/lib/types/src/config/models/CountryMatchRule.d.ts

@@ -0,0 +1,10 @@
+import type { BaseMatch } from './BaseMatch';
+import type { BaseRuleWithCountryCodeValue } from './BaseRuleWithCountryCodeValue';
+import type { ChoiceMatchingOptions } from './ChoiceMatchingOptions';
+import type { CountryMatchRulesTypes } from './CountryMatchRulesTypes';
+export type CountryMatchRule = (BaseRuleWithCountryCodeValue & {
+    rule_type: CountryMatchRulesTypes;
+    matching?: (BaseMatch & {
+        match_type?: ChoiceMatchingOptions;
+    });
+});

package/lib/types/src/config/models/CountryMatchRulesTypes.d.ts

@@ -0,0 +1,3 @@
+export declare enum CountryMatchRulesTypes {
+    COUNTRY = "country"
+}

package/lib/types/src/config/models/DayOfWeekMatchRule.d.ts

@@ -0,0 +1,10 @@
+import type { BaseMatch } from './BaseMatch';
+import type { BaseRuleWithDayOfWeekValue } from './BaseRuleWithDayOfWeekValue';
+import type { DayOfWeekMatchRulesTypes } from './DayOfWeekMatchRulesTypes';
+import type { NumericMatchingOptions } from './NumericMatchingOptions';
+export type DayOfWeekMatchRule = (BaseRuleWithDayOfWeekValue & {
+    rule_type: DayOfWeekMatchRulesTypes;
+    matching?: (BaseMatch & {
+        match_type?: NumericMatchingOptions;
+    });
+});

package/lib/types/src/config/models/DayOfWeekMatchRulesTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum DayOfWeekMatchRulesTypes {
+    LOCAL_TIME_DAY_OF_WEEK = "local_time_day_of_week",
+    PROJECT_TIME_DAY_OF_WEEK = "project_time_day_of_week"
+}

package/lib/types/src/config/models/DomInteractionGoal.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigGoalBase } from './ConfigGoalBase';
+import type { DomInteractionGoalSettings } from './DomInteractionGoalSettings';
+export type DomInteractionGoal = (ConfigGoalBase & {
+    type?: DomInteractionGoal.type;
+    settings?: DomInteractionGoalSettings;
+});
+export declare namespace DomInteractionGoal {
+    enum type {
+        DOM_INTERACTION = "dom_interaction"
+    }
+}

package/lib/types/src/config/models/DomInteractionGoalSettings.d.ts

@@ -0,0 +1,15 @@
+export type DomInteractionGoalSettings = {
+    /**
+     * Array of Events to be tracked by this goal
+     */
+    tracked_items: Array<{
+        /**
+         * Css selector that identifies the DOM element(s) on which 'event' is to be monitored in order to fire the goal.
+         */
+        selector?: string;
+        /**
+         * The event to monitor in order to fire the goal.
+         */
+        event?: string;
+    }>;
+};

package/lib/types/src/config/models/ErrorData.d.ts

@@ -0,0 +1,5 @@
+export type ErrorData = {
+    code?: number;
+    message?: string;
+    fields?: string;
+};

package/lib/types/src/config/models/ExperienceBucketedMatchRule.d.ts

@@ -0,0 +1,9 @@
+import type { BaseMatch } from './BaseMatch';
+import type { BaseRuleWithExperienceBucketedValue } from './BaseRuleWithExperienceBucketedValue';
+import type { ChoiceMatchingOptions } from './ChoiceMatchingOptions';
+export type ExperienceBucketedMatchRule = (BaseRuleWithExperienceBucketedValue & {
+    rule_type: string;
+    matching?: (BaseMatch & {
+        match_type?: ChoiceMatchingOptions;
+    });
+});

package/lib/types/src/config/models/ExperienceChange.d.ts

@@ -0,0 +1,10 @@
+import type { ExperienceChangeCustomCodeData } from './ExperienceChangeCustomCodeData';
+import type { ExperienceChangeDefaultCodeData } from './ExperienceChangeDefaultCodeData';
+import type { ExperienceChangeDefaultCodeMultipageData } from './ExperienceChangeDefaultCodeMultipageData';
+import type { ExperienceChangeDefaultRedirectData } from './ExperienceChangeDefaultRedirectData';
+import type { ExperienceChangeFullStackFeature } from './ExperienceChangeFullStackFeature';
+import type { ExperienceChangeRichStructureData } from './ExperienceChangeRichStructureData';
+/**
+ * Object that represents one change done inside an experience
+ */
+export type ExperienceChange = (ExperienceChangeDefaultCodeData | ExperienceChangeDefaultCodeMultipageData | ExperienceChangeDefaultRedirectData | ExperienceChangeCustomCodeData | ExperienceChangeRichStructureData | ExperienceChangeFullStackFeature);

package/lib/types/src/config/models/ExperienceChangeAdd.d.ts

@@ -0,0 +1,10 @@
+import type { ExperienceChangeCustomCodeDataAdd } from './ExperienceChangeCustomCodeDataAdd';
+import type { ExperienceChangeDefaultCodeDataAdd } from './ExperienceChangeDefaultCodeDataAdd';
+import type { ExperienceChangeDefaultCodeMultipageDataAdd } from './ExperienceChangeDefaultCodeMultipageDataAdd';
+import type { ExperienceChangeDefaultRedirectDataAdd } from './ExperienceChangeDefaultRedirectDataAdd';
+import type { ExperienceChangeFullStackFeatureAdd } from './ExperienceChangeFullStackFeatureAdd';
+import type { ExperienceChangeRichStructureDataAdd } from './ExperienceChangeRichStructureDataAdd';
+/**
+ * Object that represents one change done inside an experience, used when adding changes
+ */
+export type ExperienceChangeAdd = (ExperienceChangeDefaultCodeDataAdd | ExperienceChangeDefaultCodeMultipageDataAdd | ExperienceChangeDefaultRedirectDataAdd | ExperienceChangeCustomCodeDataAdd | ExperienceChangeRichStructureDataAdd | ExperienceChangeFullStackFeatureAdd);

package/lib/types/src/config/models/ExperienceChangeBase.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Object that represents the change done inside an experience
+ */
+export type ExperienceChangeBase = {
+    type?: ExperienceChangeBase.type;
+    /**
+     * This contains all data of this change, any code, settings etc
+     *
+     * This is sent by default in the following requests responses: **getExperienceChange**;
+     *
+     * All other responses that return this field, will only return it if "include" request parameter contains its name
+     *
+     * Data object structure will correspond to the "type" field
+     *
+     */
+    data?: Record<string, any>;
+};
+export declare namespace ExperienceChangeBase {
+    enum type {
+        RICH_STRUCTURE = "richStructure",
+        CUSTOM_CODE = "customCode",
+        DEFAULT_CODE = "defaultCode",
+        DEFAULT_CODE_MULTIPAGE = "defaultCodeMultipage",
+        DEFAULT_REDIRECT = "defaultRedirect",
+        FULL_STACK_FEATURE = "fullStackFeature"
+    }
+}

package/lib/types/src/config/models/ExperienceChangeCustomCodeData.d.ts

@@ -0,0 +1,6 @@
+import type { ExperienceChangeCustomCodeDataBase } from './ExperienceChangeCustomCodeDataBase';
+import type { ExperienceChangeIdReadOnly } from './ExperienceChangeIdReadOnly';
+/**
+ * Describes structure for "defaultCode" type of experience change
+ */
+export type ExperienceChangeCustomCodeData = (ExperienceChangeIdReadOnly & ExperienceChangeCustomCodeDataBase);

package/lib/types/src/config/models/ExperienceChangeCustomCodeDataAdd.d.ts

@@ -0,0 +1,6 @@
+import type { ExperienceChangeCustomCodeDataBase } from './ExperienceChangeCustomCodeDataBase';
+import type { ExperienceChangeIdReadOnly } from './ExperienceChangeIdReadOnly';
+/**
+ * Describes structure for "defaultCode" type of experience change
+ */
+export type ExperienceChangeCustomCodeDataAdd = (ExperienceChangeIdReadOnly & ExperienceChangeCustomCodeDataBase);

package/lib/types/src/config/models/ExperienceChangeCustomCodeDataBase.d.ts

@@ -0,0 +1,29 @@
+import type { ExperienceChangeBase } from './ExperienceChangeBase';
+/**
+ * Describes structure for "defaultCode" type of experience change
+ */
+export type ExperienceChangeCustomCodeDataBase = (ExperienceChangeBase & {
+    type?: ExperienceChangeCustomCodeDataBase.type;
+    /**
+     * Describes structure for "defaultCode" type of experience change
+     */
+    data?: {
+        /**
+         * CSS code to be applied by this change
+         */
+        css?: string | null;
+        /**
+         * Custom javascript code to be applied by this change
+         */
+        js?: string | null;
+        /**
+         * The **id** of the page connected to this change, in case this is a **multi-page** experiment
+         */
+        page_id?: string;
+    };
+});
+export declare namespace ExperienceChangeCustomCodeDataBase {
+    enum type {
+        CUSTOM_CODE = "customCode"
+    }
+}

package/lib/types/src/config/models/ExperienceChangeCustomCodeDataUpdate.d.ts

@@ -0,0 +1,6 @@
+import type { ExperienceChangeCustomCodeDataBase } from './ExperienceChangeCustomCodeDataBase';
+import type { ExperienceChangeId } from './ExperienceChangeId';
+/**
+ * Describes structure for "customCode" type of experience change
+ */
+export type ExperienceChangeCustomCodeDataUpdate = (ExperienceChangeId & ExperienceChangeCustomCodeDataBase);

package/lib/types/src/config/models/ExperienceChangeCustomCodeDataUpdateNoId.d.ts

@@ -0,0 +1,5 @@
+import type { ExperienceChangeCustomCodeDataBase } from './ExperienceChangeCustomCodeDataBase';
+/**
+ * Describes structure for "customCode" type of experience change
+ */
+export type ExperienceChangeCustomCodeDataUpdateNoId = ExperienceChangeCustomCodeDataBase;

package/lib/types/src/config/models/ExperienceChangeDefaultCodeData.d.ts

@@ -0,0 +1,6 @@
+import type { ExperienceChangeDefaultCodeDataBase } from './ExperienceChangeDefaultCodeDataBase';
+import type { ExperienceChangeIdReadOnly } from './ExperienceChangeIdReadOnly';
+/**
+ * Describes structure for "defaultCode" type of experience change
+ */
+export type ExperienceChangeDefaultCodeData = (ExperienceChangeIdReadOnly & ExperienceChangeDefaultCodeDataBase);

package/lib/types/src/config/models/ExperienceChangeDefaultCodeDataAdd.d.ts

@@ -0,0 +1,6 @@
+import type { ExperienceChangeDefaultCodeDataBase } from './ExperienceChangeDefaultCodeDataBase';
+import type { ExperienceChangeIdReadOnly } from './ExperienceChangeIdReadOnly';
+/**
+ * Describes structure for adding a "defaultCode" type of experience change
+ */
+export type ExperienceChangeDefaultCodeDataAdd = (ExperienceChangeIdReadOnly & ExperienceChangeDefaultCodeDataBase);