@uniformdev/context 20.34.3-alpha.70 → 20.35.1-alpha.188

package/dist/types-HcKr1VVF.d.mts

@@ -0,0 +1,1403 @@
+import * as mitt from 'mitt';
+import { Emitter } from 'mitt';
+
+type Quirks = {
+    [key: string]: string;
+};
+type Tests = {
+    [key: string]: string;
+};
+type ScoreVector = {
+    [key: string]: number;
+};
+type Goals = {
+    [key: string]: boolean;
+};
+type EnrichmentData = {
+    /** Enrichment category name */
+    cat: string;
+    /** Enrichment key value */
+    key: string;
+    /** Strength value (amount of score added when viewing content) */
+    str: number;
+};
+type PersonalizeControlVariant = {
+    index: number;
+    control: boolean;
+};
+type PersonalizeVariants = {
+    [key: string]: PersonalizeControlVariant[];
+};
+/** An event that has occurred (i.e. an analytics track) which may trigger an Event signal */
+type EventData = {
+    /** The event name that has been fired */
+    event: string;
+};
+type VisitorData = {
+    /**
+     * Quirk key-value data.
+     * NOTE: Context.quirks is more commonly correct if you need to read quirks data.
+     */
+    quirks: Quirks;
+    /** A/B test variant selections */
+    tests: Tests;
+    /**
+     * Personalization score data for the current session (merge with all time for totals)
+     * NOTE: Context.scores is more commonly correct to read scores instead of this value.
+     */
+    sessionScores: ScoreVector;
+    /**
+     * Personalization score data for all time (merge with session for totals)
+     * NOTE: Context.scores is more commonly correct to read scores instead of this value.
+     */
+    scores: ScoreVector;
+    /**
+     * Goals that this user has triggered.
+     */
+    goals?: Goals;
+    /**
+     * Whether consent has been given to store the visitor data
+     * If false or not set: visitor data is stored in memory and is lost if the browser refreshes
+     * If true: visitor data is stored in localStorage and any other transition storage if registered
+     */
+    consent?: boolean;
+    /**
+     * Whether the visitor has been assigned to the personalization control group -
+     * visitors who are not shown personalization. If this is true, all scores will be zeroed,
+     * and score updates will be ignored. This has no effect on quirks or tests.
+     *
+     * If this value is not set, a random roll will be performed to determine membership,
+     * based on the control group size.
+     */
+    controlGroup?: boolean;
+    /**
+     * Records of personalized variants that have been shown to the visitor and their control group status
+     */
+    personalizeVariants?: PersonalizeVariants;
+};
+declare const emptyVisitorData: () => VisitorData;
+/**
+ * Canvas-specific data that should be managed separately from regular context updates
+ */
+type CompositionMetadata = {
+    /** The composition ID always required, otherwise whole metadata should not be set */
+    compositionId: string;
+    /** The matched route from router endpoint. Same as matched project map node pathname */
+    matchedRoute?: string;
+    /** Dynamic inputs for the route */
+    dynamicInputs?: Record<string, string>;
+};
+/**
+ * Expresses a 'patch' to the Uniform Context state
+ */
+type ContextState = {
+    cookies: Record<string, string | undefined>;
+    url?: URL;
+    quirks: Quirks;
+    enrichments: EnrichmentData[];
+    events: EventData[];
+    /**
+     * Metadata about the composition that is being rendered right now.
+     * if you have multiple compositions on the page, please set this one manually.
+     */
+    compositionMetadata?: CompositionMetadata;
+};
+type ContextStateUpdate = {
+    /** The new effective state of the visitor after this state update is applied */
+    state: Partial<ContextState>;
+    /** The last state of the visitor before this state update */
+    previousState: Partial<ContextState>;
+    /** The visitor we are updating */
+    visitor: VisitorData;
+    /** The visitor's scores before this state update */
+    scores: ScoreVector;
+};
+type GoalStateUpdate = {
+    scores: ScoreVector | undefined;
+    quirks: Quirks | undefined;
+};
+
+type StorageCommand<TID extends string = string, TData = unknown> = {
+    type: TID;
+    data: TData;
+};
+/** Commands that can be issued to alter the storage of Uniform Context data */
+type StorageCommands = ModifyScoreCommand | ModifySessionScoreCommand | SetConsentCommand | SetQuirkCommand | SetTestCommand | IdentifyCommand | SetControlGroupCommand | SetPersonalizeVariantControlCommand | SetGoalCommand;
+/**
+ * Converts the goal specified.
+ */
+type SetGoalCommand = StorageCommand<'setgoal', {
+    goal: string;
+}>;
+/**
+ * Changes the visitor's permanent score for a given dimension
+ */
+type ModifyScoreCommand = StorageCommand<'modscore', {
+    dimension: string;
+    delta: number;
+}>;
+/**
+ * Changes the visitor's session (time-based) score for a given dimension
+ */
+type ModifySessionScoreCommand = StorageCommand<'modscoreS', {
+    dimension: string;
+    delta: number;
+}>;
+/**
+ * Changes the visitor's storage consent setting.
+ * Setting consent to false will trigger deletion of any stored data for the visitor.
+ * Scores are still collected in-memory when consent is false; just not persisted.
+ */
+type SetConsentCommand = StorageCommand<'consent', boolean>;
+/** Sets a permanent quirk key and value for the visitor */
+type SetQuirkCommand = StorageCommand<'setquirk', {
+    key: string;
+    value: string;
+}>;
+/** Sets a specific variant as being this visitor's variant on an A/B test */
+type SetTestCommand = StorageCommand<'settest', {
+    test: string;
+    variant: string;
+}>;
+/**
+ * Identifies the visitor as being a specific unique identifier.
+ * NOTE: this only has an effect when using an external cross-device transition storage system.
+ * NOTE: you cannot read the identified visitor ID back from the storage system once it is set.
+ */
+type IdentifyCommand = StorageCommand<'identify', {
+    identity: string;
+}>;
+/**
+ * Sets whether the current visitor is in the personalization control group
+ * (Will not be exposed to personalization or gather classification data; WILL see A/B tests)
+ * In most cases this should not be sent as the membership is computed automatically for visitors;
+ * this command is intended mostly for diagnostics and testing purposes.
+ */
+type SetControlGroupCommand = StorageCommand<'setcontrol', boolean>;
+type SetPersonalizeVariantControlCommand = StorageCommand<'setpersonalizecontrol', {
+    personlizationName: string;
+    index: number;
+    control: boolean;
+}>;
+declare const areCommandsEqual: (a: StorageCommands, b: StorageCommands) => boolean;
+
+type TransitionDataStoreOptions = {
+    initialData?: Partial<VisitorData>;
+};
+type ServerToClientTransitionState = Pick<Partial<VisitorData>, 'quirks' | 'tests' | 'personalizeVariants'> & {
+    /**
+     * Server Score Vector - the resultant scores _on the server side_ after the server/edge render completes
+     * Note that the client side does not trust these scores; they are only used until it's done with initial
+     * recomputation.
+     */
+    ssv?: ScoreVector;
+    /**
+     * Storage commands that the server
+     */
+    commands?: StorageCommands[];
+    /**
+     * Composition metadata from the server side
+     */
+    compositionMetadata?: CompositionMetadata;
+};
+declare const SERVER_STATE_ID = "__UNIFORM_DATA__";
+type TransitionDataStoreEvents = {
+    /**
+     * Fired when the data is updated asynchronously
+     * (i.e. a promise resolves with new data from a backend)
+     *
+     * NOT fired for synchronous updates (e.g. calling updateData()), unless this also results in an async update of the data afterwards.
+     * NOT fired if an asynchronous update does not result in any change compared to the last known data.
+     */
+    dataUpdatedAsync: Partial<VisitorData>;
+};
+declare abstract class TransitionDataStore {
+    #private;
+    constructor({ initialData }: TransitionDataStoreOptions);
+    get data(): Partial<VisitorData> | undefined;
+    get initialData(): Partial<VisitorData> | undefined;
+    /**
+     * Subscribe to events from the transition storage
+     */
+    readonly events: {
+        on: {
+            <Key extends "dataUpdatedAsync">(type: Key, handler: mitt.Handler<TransitionDataStoreEvents[Key]>): void;
+            (type: "*", handler: mitt.WildcardHandler<TransitionDataStoreEvents>): void;
+        };
+        off: {
+            <Key extends "dataUpdatedAsync">(type: Key, handler?: mitt.Handler<TransitionDataStoreEvents[Key]> | undefined): void;
+            (type: "*", handler: mitt.WildcardHandler<TransitionDataStoreEvents>): void;
+        };
+    };
+    /**
+     * Updates data in the transition storage.
+     * @param commands Commands to execute against existing stored value (event based stores)
+     * @param computedValue Pre-computed new value against existing value (object based stores)
+     * @returns Resolved promise when the data has been updated
+     */
+    updateData(commands: StorageCommands[], computedValue: VisitorData): Promise<void>;
+    /**
+     * Deletes a visitor's stored data, forgetting them.
+     * @param fromAllDevices - false: logout from this device ID. true: forget all data about the visitor and their identity.
+     */
+    delete(fromAllDevices?: boolean): Promise<void>;
+    /**
+     * Deletes a visitor's stored data, forgetting them.
+     * Important: do not emit any async score update events from this function.
+     * @param fromAllDevices - false: logout from this device ID. true: forget all data about the visitor and their identity.
+     */
+    abstract handleDelete(fromAllDevices?: boolean): Promise<void>;
+    /**
+     * Updates visitor data in the transition store.
+     *
+     * NOTE: The updated data is optimistically stored in TransitionDataStore automatically,
+     * so unless the updated data is _changed_ by the backend data store, there is no need
+     * to emit async score changed events when the visitor data is done updating.
+     */
+    abstract handleUpdateData(commands: StorageCommands[], computedValue: VisitorData): Promise<void>;
+    protected signalAsyncDataUpdate(newScores: Partial<VisitorData>): void;
+    /**
+     * When we load on the client side after a server side rendering has occurred (server to client transition),
+     * we can have a page script (ID: __UNIFORM_DATA__) that contains the computed visitor data from the SSR/edge render.
+     * This data is injected into the first render to allow score syncing and the server to request commands be applied
+     * to the client side data store.
+     */
+    getClientTransitionState(): ServerToClientTransitionState | undefined;
+}
+
+type DecayOptions = {
+    now: number;
+    lastUpd: number | undefined;
+    scores: ScoreVector;
+    sessionScores: ScoreVector;
+    onLogMessage?: (message: LogMessage) => void;
+};
+/**
+ * Computes decay of visitor scores over time.
+ * NOTE: it is expected that this function mutates the incoming score vectors,
+ * if it needs to apply score decay. The data store ensures immutability already.
+ *
+ * @returns true if any decay was applied, false otherwise
+ */
+type DecayFunction = (options: DecayOptions) => boolean;
+
+type VisitorDataStoreOptions = {
+    /** Transition storage used to transfer server or edge side execution state to the client. Unused for client side only. */
+    transitionStore?: TransitionDataStore;
+    /** Duration of a 'visit' measured by this number of milliseconds without performing any updates */
+    visitLifespan?: number;
+    /** Personalization manifest data. If set, the data store will automatically apply score caps in the manifest data. */
+    manifest?: ManifestInstance;
+    /** Allows decaying of scores over time based on time between visits. Default: no decay */
+    decay?: DecayFunction;
+    /**
+     * Sets the default value of storage consent for new unknown visitors.
+     * If storage consent is not given, only in-memory data will be stored which is lost when the browser leaves the page.
+     * @default false - consent is not given for new visitors until they explicitly give it with an update command
+     */
+    defaultConsent?: boolean;
+    /**
+     * Function called when server-to-client transfer state is loaded and contains server-side computed scores.
+     * These scores are used as a temporary shim for the current scores on the client side, until score computation
+     * is completed the first time (which occurs when the current url is fed into the Context).
+     *
+     * Because the feed of the URL may be marginally delayed (for example in React it's in an effect so it's a second render),
+     * one render might be done with _no_ scores unless we dropped the server scores in temporarily, resulting in a flash of unpersonalized content.
+     */
+    onServerTransitionReceived?: (state: ServerToClientTransitionState) => void;
+    /** Called when a log message is emitted from the data store */
+    onLogMessage?: (message: LogMessage) => void;
+    /**
+     * Optionally specify a prefix for all storage keys.
+     * Only required if using multiple Context instances on the same domain and need to separate them.
+     */
+    partitionKey?: string;
+};
+type VisitorDataStoreEvents = {
+    /**
+     * Fired when the stored data is updated.
+     * This is fired for any update, whether from integrated or transition storage.
+     * The event is NOT fired if an update does not result in any score changes.
+     */
+    scoresUpdated: Pick<VisitorData, 'scores' | 'sessionScores'>;
+    /**
+     * Fired when stored quirks are updated.
+     * This is fired for any update, whether from integrated or transition storage.
+     * The event is NOT fired if an update does not result in any quirk changes.
+     */
+    quirksUpdated: Pick<VisitorData, 'quirks'>;
+    /**
+     * Fired when test variant selection is updated.
+     */
+    testsUpdated: Pick<VisitorData, 'tests'>;
+    /**
+     * Fired when storage consent is changed
+     */
+    consentUpdated: Pick<VisitorData, 'consent'>;
+    /**
+     * Fired when visitor control group membership is changed
+     */
+    controlGroupUpdated: Pick<VisitorData, 'controlGroup'>;
+    /**
+     * Fired when a goal is converted
+     */
+    goalConverted: {
+        goalId: string;
+    };
+    /** Fired when storage update commands are done executing */
+    commandsExecuted: StorageCommands[];
+};
+declare class VisitorDataStore {
+    #private;
+    constructor(options: VisitorDataStoreOptions);
+    /** Gets the current visitor data. This property is always up to date. */
+    get data(): VisitorData;
+    get decayEnabled(): boolean;
+    get options(): VisitorDataStoreOptions;
+    /**
+     * Subscribe to events from storage
+     */
+    readonly events: {
+        on: {
+            <Key extends keyof VisitorDataStoreEvents>(type: Key, handler: mitt.Handler<VisitorDataStoreEvents[Key]>): void;
+            (type: "*", handler: mitt.WildcardHandler<VisitorDataStoreEvents>): void;
+        };
+        off: {
+            <Key extends keyof VisitorDataStoreEvents>(type: Key, handler?: mitt.Handler<VisitorDataStoreEvents[Key]> | undefined): void;
+            (type: "*", handler: mitt.WildcardHandler<VisitorDataStoreEvents>): void;
+        };
+    };
+    /** Push data update command(s) into the visitor data */
+    updateData(commands: StorageCommands[]): Promise<void>;
+    /**
+     * Deletes visitor data (forgetting them)
+     * In most cases you should use forget() on the Context instead of this function, which also clears the Context state.
+     * @param fromAllDevices for an identified user, whether to delete all their data (for the entire account) - true, or data for this device (sign out) - false
+     */
+    delete(fromAllDevices: boolean): Promise<void>;
+}
+
+declare class ManifestInstance {
+    #private;
+    readonly data: ManifestV2;
+    constructor({ manifest, evaluator, onLogMessage, }: {
+        manifest: ManifestV2;
+        evaluator?: GroupCriteriaEvaluator;
+        onLogMessage?: (message: LogMessage) => void;
+    });
+    rollForControlGroup(): boolean;
+    getTest(name: string): TestDefinition | undefined;
+    computeSignals(update: ContextStateUpdate): StorageCommands[];
+    computeGoals(data: GoalStateUpdate): StorageCommands[];
+    /**
+     * Computes aggregated scores based on other dimensions
+     */
+    computeAggregateDimensions(primitiveScores: ScoreVector): ScoreVector;
+    getDimensionByKey(scoreKey: string): EnrichmentCategory | Signal | undefined;
+    getAggregateDimensionByKey(scoreKey: string): AggregateDimension | undefined;
+}
+
+interface paths {
+    "/api/v2/manifest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Fetches the optimization Manifest for a given project.
+         *     If no manifest has ever been published, and an API key is used that has preview manifest permissions then the current preview manifest will be returned (in delivery format).
+         *      */
+        get: {
+            parameters: {
+                query: {
+                    preview?: boolean;
+                    projectId: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ManifestV2"];
+                    };
+                };
+                400: components["responses"]["BadRequestError"];
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                /** @description No manifest has ever been published, and the API key does not have preview permissions */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/plain": string;
+                    };
+                };
+                429: components["responses"]["RateLimitError"];
+                500: components["responses"]["InternalServerError"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        /** @description Handles preflight requests. This endpoint allows CORS. */
+        options: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        ManifestV2: {
+            project: {
+                /**
+                 * Format: uuid
+                 * @description is not present unless getting a preview manifest
+                 */
+                id?: string;
+                /** @description is not present unless getting a preview manifest */
+                name?: string;
+                /** @description is not present unless getting a preview manifest */
+                ui_version?: number;
+                pz?: components["schemas"]["PersonalizationManifest"];
+                /** @description A/B test settings */
+                test?: {
+                    [key: string]: components["schemas"]["Test"];
+                };
+            };
+        };
+        PersonalizationManifest: {
+            /** @description Map of all signals defined for personalization criteria */
+            sig?: {
+                [key: string]: components["schemas"]["Signal"];
+            };
+            /** @description Map of all enrichment categories defined for personalization criteria */
+            enr?: {
+                [key: string]: components["schemas"]["EnrichmentCategory"];
+            };
+            /** @description Map of all aggregate dimensions (intents or audiences) defined for personalization criteria */
+            agg?: {
+                [key: string]: components["schemas"]["AggregateDimension"];
+            };
+            /** @description Percentage of visitors that will be used as a personalization control group (not shown any personalization) */
+            control?: number;
+        };
+        SignalCriteriaGroup: {
+            /**
+             * @description Criteria type (Group of other criteria)
+             * @enum {string}
+             */
+            type: "G";
+            /**
+             * @description The logical operator to apply to the criteria groups
+             *     & = AND
+             *     | = OR
+             *
+             *     Default is `&` if unspecified
+             *
+             * @enum {string}
+             */
+            op?: "&" | "|";
+            /** @description The criteria clauses that make up this grouping of criteria */
+            clauses: (components["schemas"]["SignalCriteriaGroup"] | components["schemas"]["SignalCriteria"])[];
+        };
+        /** @description Describes a match expression on a string */
+        StringMatch: {
+            /** @description The right-hand side of the match expression */
+            rhs: string;
+            /**
+             * @description The match operator
+             *     '=' = exact match
+             *     '~' = contains match
+             *     '//' = regular expression match
+             *
+             *     Any of the above can be prefixed with '!' to invert the match (i.e. != for 'not an exact match')
+             *
+             * @enum {string}
+             */
+            op: "=" | "~" | "//" | "!=" | "!~" | "!//";
+            /** @description The case sensitivity of the match. Defaults to false if unspecified */
+            cs?: boolean;
+        } | {
+            /**
+             * @description The type of match to perform
+             *     '*' = exists with any value
+             *     '!*' = does not exist
+             *
+             * @enum {string}
+             */
+            op: "*" | "!*";
+        };
+        /** @description Matches a web cookie value */
+        CookieCriteria: {
+            /** @enum {string} */
+            type: "CK";
+            /** @description The name of the cookie to match */
+            cookieName: string;
+            /** @description The value to match the cookie against */
+            match: components["schemas"]["StringMatch"];
+        };
+        /** @description Matches a URL query string parameter value */
+        QueryStringCriteria: {
+            /** @enum {string} */
+            type: "QS";
+            /** @description The name of the query string parameter to match */
+            queryName: string;
+            /** @description The value to match the query string parameter against */
+            match: components["schemas"]["StringMatch"];
+        };
+        /** @description Matches a visitor quirk key and value */
+        QuirkCriteria: {
+            /** @enum {string} */
+            type: "QK";
+            /** @description The name of the quirk key to match */
+            key: string;
+            /** @description The quirk value to match against */
+            match: components["schemas"]["StringMatch"];
+        };
+        /** @description Matches an analytics event name being fired */
+        EventCriteria: {
+            /** @enum {string} */
+            type: "EVT";
+            /** @description How to match the event name */
+            event: components["schemas"]["StringMatch"];
+        };
+        /** @description Matches the current page's absolute path (i.e. /path/to/page.html)
+         *     Does not include the query string or protocol and hostname (i.e. NOT https://foo.com/path/to/page.html?query=something)
+         *      */
+        CurrentPageCriteria: {
+            /** @enum {string} */
+            type: "PV";
+            /** @description The page/route path to match as a page that has been visited */
+            path: components["schemas"]["StringMatch"];
+        };
+        /** @description Describes a match expression on a number */
+        NumberMatch: {
+            /** @description The right-hand side of the match expression */
+            rhs: number;
+            /**
+             * @description The type of match to perform
+             *     '=' = exact match
+             *     '!=' = not an exact match
+             *     '<' = less than match expression
+             *     '>' = greater than match expression
+             *
+             * @enum {string}
+             */
+            op: "=" | "<" | ">" | "!=";
+        };
+        PageViewCountCriteria: {
+            /** @enum {string} */
+            type: "PVC";
+            /** @description The expression to match the page view count against */
+            match: components["schemas"]["NumberMatch"];
+        };
+        SignalCriteria: components["schemas"]["CookieCriteria"] | components["schemas"]["QueryStringCriteria"] | components["schemas"]["QuirkCriteria"] | components["schemas"]["EventCriteria"] | components["schemas"]["CurrentPageCriteria"] | components["schemas"]["PageViewCountCriteria"];
+        RootSignalCriteriaGroup: {
+            /**
+             * @description Criteria type (Group of other criteria)
+             * @enum {string}
+             */
+            type: "G";
+            /**
+             * @description The logical operator to apply to the criteria groups
+             *     & = AND
+             *     | = OR
+             *
+             *     Default is `&` if unspecified
+             *
+             * @default &
+             * @enum {string}
+             */
+            op?: "&" | "|";
+            /** @description The criteria clauses that make up this grouping of criteria */
+            clauses: (components["schemas"]["SignalCriteriaGroup"] | components["schemas"]["SignalCriteria"])[];
+        };
+        Conversion: {
+            /**
+             * @description The frequency of the conversion event
+             * @enum {string}
+             */
+            freq: "O";
+        };
+        Signal: {
+            /** @description The signal strength per activation (each time its criteria are true, this score is added) */
+            str: number;
+            /** @description The maximum visitor score allowed for this signal */
+            cap: number;
+            /**
+             * @description How long the signal's score should persist
+             *     's' = current session (expires after a period of inactivity)
+             *     'p' = permanent (expires as far in the future as possible, may be limited by browser security settings)
+             *     't' = transient (score tracks the current state of the criteria every time scores are updated)
+             *
+             * @enum {string}
+             */
+            dur: "s" | "p" | "t";
+            crit: components["schemas"]["RootSignalCriteriaGroup"];
+            conversion?: components["schemas"]["Conversion"] | null;
+        };
+        EnrichmentCategory: {
+            /** @description The maximum visitor score allowed for enrichment keys in this category */
+            cap: number;
+        };
+        /** @description Defines an input dimension to an aggregate dimension */
+        AggregateDimensionInput: {
+            /** @description Dimension name to reference as an input.
+             *     For enrichment inputs, use CATEGORY_KEY as the dimension.
+             *     Enrichments, signals, and other aggregate dimensions may be referenced.
+             *
+             *     Note that creating a cycle of aggregate dimensions is allowed, however
+             *     the final score will _ignore_ the cycled aggregate dimension in the result.
+             *     This can be used to create mutually exclusive aggregates
+             *      */
+            dim: string;
+            /**
+             * @description The sign of the input dimension controls how it affects the aggregate dimension's final score.
+             *
+             *     '+' = add to the final score
+             *     '-' = subtract from the final score
+             *     'c' = clear the final score (if the input dimension has any score at all, this aggregate will have no score regardless of other inputs)
+             *
+             *     Default if unspecified: '+'
+             *
+             * @default +
+             * @enum {string}
+             */
+            sign?: "+" | "-" | "c";
+        };
+        /** @description Defines an aggregate dimension that is a grouping of other dimensions' scores; an intent or audience */
+        AggregateDimension: {
+            /** @description Input dimensions to the aggregate dimension */
+            inputs: components["schemas"]["AggregateDimensionInput"][];
+        };
+        Test: {
+            /** @description Winning variation ID - if set, the test will not run and this variation is shown to all visitors (the test is closed) */
+            wv?: string;
+        };
+        Error: {
+            /** @description Error message(s) that occurred while processing the request */
+            errorMessage?: string[] | string;
+        };
+    };
+    responses: {
+        /** @description Request input validation failed */
+        BadRequestError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description API key or token was not valid */
+        UnauthorizedError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description Permission was denied */
+        ForbiddenError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description Too many requests in allowed time period */
+        RateLimitError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
+        };
+        /** @description Execution error occurred */
+        InternalServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+type ManifestV2 = components['schemas']['ManifestV2'];
+type PersonalizationManifest = components['schemas']['PersonalizationManifest'];
+type Signal = components['schemas']['Signal'];
+type SignalCriteriaGroup = components['schemas']['SignalCriteriaGroup'];
+type SignalCriteria = components['schemas']['SignalCriteria'];
+type EnrichmentCategory = components['schemas']['EnrichmentCategory'];
+type StringMatch = components['schemas']['StringMatch'];
+type NumberMatch = components['schemas']['NumberMatch'];
+type TestDefinition = components['schemas']['Test'];
+type AggregateDimension = components['schemas']['AggregateDimension'];
+type AggregateDimensionInput = components['schemas']['AggregateDimensionInput'];
+
+declare class GroupCriteriaEvaluator {
+    #private;
+    constructor(criteriaEvaluators: Record<string, CriteriaEvaluator>);
+    evaluate(update: ContextStateUpdate, crit: SignalCriteriaGroup, commands: StorageCommands[], signal: SignalData, onLogMessage?: (message: LogMessage) => void): CriteriaEvaluatorResult;
+}
+
+/**
+ * The result of evaluating a signal criteria.
+ */
+type CriteriaEvaluatorResult = {
+    /** Whether the criteria evaluated to true or not */
+    result: boolean;
+    /**
+     * Whether the value of the criteria changed from the previous state
+     * If ALL criteria on a signal have NOT changed, the signal is skipped
+     * and its score is left alone.
+     */
+    changed: boolean;
+};
+type CriteriaEvaluatorParameters = {
+    /** The update being made to the Context state */
+    update: ContextStateUpdate;
+    /** Current criteria to evaluate the update against */
+    criteria: SignalCriteria;
+    /**
+     * The storage commands that will be executed by this update.
+     * If the evaluation requires custom commands, push them into this parameter.
+     * NOTE: needing to use this is very rare and should be avoided if possible.
+     */
+    commands: StorageCommands[];
+    /** The parent signal containing the criteria we are evaluating */
+    signal: SignalData;
+    /** Function to emit log notices to the Context log */
+    onLogMessage?: (message: LogMessage) => void;
+};
+type SignalData = Signal & {
+    id: string;
+};
+/**
+ * A type that evaluates a signal criteria type and
+ * decides if it matches the current Context state or not.
+ */
+type CriteriaEvaluator = ((parameters: CriteriaEvaluatorParameters) => CriteriaEvaluatorResult) & {
+    /** If true the criteria will always execute even if a short-circuit would normally skip it */
+    alwaysExecute?: boolean;
+};
+
+/** Defines all error codes and their parameter(s)  */
+type LogMessages = {
+    /** Context constructed */
+    1: MessageFunc;
+    /** Context received data update */
+    2: MessageFunc<Partial<Omit<ContextState, 'url'> & {
+        url: string;
+    }>>;
+    /** Context emitted new score vector */
+    3: MessageFunc<ScoreVector>;
+    /** Context emitted updated quirks */
+    4: MessageFunc<Quirks>;
+    /** Tried to set enrichment category that did not exist */
+    5: MessageFunc<EnrichmentData>;
+    /** Storage received update commands */
+    101: MessageFunc<StorageCommands[]>;
+    /** Storage data was updated */
+    102: MessageFunc<VisitorData>;
+    /** Storage data was deleted bool: fromAllDevices */
+    103: MessageFunc<boolean>;
+    /** Visitor was assigned or removed from control group */
+    104: MessageFunc<boolean>;
+    /** Storage score was truncated to its cap */
+    110: MessageFunc<{
+        dim: string;
+        score: number;
+        cap: number;
+    }>;
+    /** Storage visitor data expired and was cleared */
+    120: MessageFunc;
+    /** Server to client transition score data was loaded */
+    130: MessageFunc<ServerToClientTransitionState>;
+    /** Server to client transition data was discarded */
+    131: MessageFunc;
+    /** Decay function executed */
+    140: MessageFunc<string>;
+    /** Signals evaluation beginning */
+    200: MessageFunc;
+    /** Evaluation of a specific signal beginning */
+    201: MessageFunc<SignalData>;
+    /** Evaluation of a group beginning */
+    202: MessageFunc<SignalCriteriaGroup>;
+    203: MessageFunc<{
+        criteria: SignalCriteria;
+        result: CriteriaEvaluatorResult;
+        explanation: string;
+    }>;
+    /** Result of evaluating a criteria group */
+    204: MessageFunc<CriteriaEvaluatorResult>;
+    /** Personalization placement executing */
+    300: MessageFunc<{
+        name: string;
+        take?: number;
+    }>;
+    /** Personalization placement testing variation */
+    301: MessageFunc<{
+        id: string;
+        op?: string;
+    }>;
+    /** Processed a personalization criteria */
+    302: MessageFunc<{
+        matched: boolean;
+        description: string;
+    }>;
+    /** Final result for a personalized variation */
+    303: MessageFunc<boolean>;
+    /** Personalization algorithm not found */
+    304: MessageFunc<{
+        algorithm: string;
+    }>;
+    /** A/B test placement executing */
+    400: MessageFunc<string>;
+    /** A/B Test definition did not exist */
+    401: MessageFunc<string>;
+    /** Previously shown test variant no longer in variant data */
+    402: MessageFunc<{
+        missingVariant: string;
+        variants: string[];
+    }>;
+    /** Selected a new A/B test variation */
+    403: MessageFunc<string>;
+    /** Displaying A/B test variation */
+    404: MessageFunc<string>;
+    /** gtag was not present on the page to emit events to */
+    700: MessageFunc;
+    /** Enabled gtag event signal redirection */
+    701: MessageFunc;
+};
+
+type Severity = 'debug' | 'info' | 'warn' | 'error';
+type MessageCategory = 'context' | 'storage' | 'testing' | 'personalization' | 'gtag' | 'signals';
+type OutputSeverity = Severity | 'none';
+type MessageFunc<TArg = void> = (arg: TArg) => [
+    /** Category of the message */
+    MessageCategory,
+    /** Log message text */
+    string,
+    /** Log message */
+    ...unknown[]
+];
+type LogMessage = LogMessageSingle | LogMessageGroup;
+type LogMessageSingle<TID extends keyof LogMessages = keyof LogMessages> = [
+    severity: Severity,
+    id: TID,
+    ...args: Parameters<LogMessages[TID]>
+];
+type LogMessageGroup<TID extends keyof LogMessages = keyof LogMessages> = [severity: Severity, id: TID, group: 'GROUP', ...args: Parameters<LogMessages[TID]>] | [severity: Severity, id: TID, group: 'ENDGROUP'];
+type LogDrain = (message: LogMessage) => void;
+
+/** Data for a personalization variation using the top-down criteria selection algorithm */
+interface VariantMatchCriteria extends VariationMatchMetadata {
+    /**
+     * Operation for match criteria
+     *
+     * @defaultValue `&`
+     */
+    op?: '&' | '|';
+    crit: Array<DimensionMatch | QuirkMatch>;
+    /**
+     * Control group percentage for the variant.
+     */
+    control?: number;
+}
+/** Data for a personalization variation using the TODO selection algorithm */
+interface VariationMatchDimensionCriteria extends VariationMatchMetadata {
+    /** The dimension this content is relevant to */
+    dim: string | undefined;
+}
+/** Data that must exist on a personalization variation regardless of selection algorithm */
+interface VariationMatchMetadata {
+    /**
+     * Name of the variation for analytics tracking.
+     * NOTE: name is optional for backwards compatibility, but it is HIGHLY recommended to specify a name
+     * as the default fallback is not helpfully named and is reliant on the order of the variations array.
+     */
+    name?: string;
+}
+type DimensionMatch = {
+    /**
+     * Left hand side of the match expression (name of dimension in score vector)
+     * NOTE: if the dimension is not present in the score vector, it will be treated as if it has a value of 0
+     */
+    l: string;
+    /**
+     * Operator of the match expression
+     * Whole-vector (RHS only) operators - these do not require a `r` or `rDim` set:
+     * +: `l` is the strongest dimension in the score vector across all categories
+     * ^: `l` is the strongest dimension in the specified category
+     * -: `l` is the weakest dimension in the score vector. This does not match if the dimension has no score at all.
+     *
+     * Comparison operators:
+     * >: `l` is greater than the right hand side expression
+     * >= : `l` is greater than or equal to the right hand side expression
+     * <: `l` is less than the right hand side expression
+     * <= : `l` is less than or equal to the right hand side expression
+     * =: `l` is equal to the right hand side expression
+     * !=: `l` is not equal to the right hand side expression
+     */
+    op: '+' | '-' | '>' | '>=' | '<' | '<=' | '=' | '!=' | '^';
+    /**
+     * Right hand side of the match expression (not required for op = + or - which have no right side)
+     * This value is treated as a constant value, if it is present. If it's a string, it is parsed to an integer.
+     * To reference another score dimension as the RHS, use the `rDim` property instead.
+     * `r` and `rDim` are mutually exclusive; if both are specified, then `rDim` wins.
+     */
+    r?: number | string;
+    /**
+     * Right hand side of the match expression (not required for op = + or - which have no right side)
+     * This value is treated as a reference to another score dimension, if it is present in the score vector.
+     * If the referenced dimension is NOT present in the score vector, the match will always be false.
+     * To reference a constant value instead as the RHS, use the `r` property instead.
+     * `r` and `rDim` are mutually exclusive; if both are specified, then `rDim` wins.
+     */
+    rDim?: string;
+};
+type QuirkMatch = {
+    /**
+     * Type of match expression; 'q' discriminates quirk matches from dimension matches
+     */
+    t: 'q';
+    /**
+     * Left hand side of the match expression (name of quirk)
+     * NOTE: if the quirk is not present
+     */
+    l: string;
+    /**
+     * Operator of the match expression
+     * Comparison operators:
+     * =: `l` is equal to the right hand side expression
+     * !=: `l` is not equal to the right hand side expression
+     */
+    op: '=' | '!=';
+    /**
+     * Right hand side of the match expression
+     * This value is treated as a constant value, if it is present. If it's a string, it is parsed to an integer.
+     * To reference another score dimension as the RHS, use the `rDim` property instead.
+     * `r` and `rDim` are mutually exclusive; if both are specified, then `rDim` wins.
+     */
+    r: string;
+    /**
+     * Only here to maintain object compatibility with DimensionMatch.
+     * Completely ignored.
+     * @deprecated this is not used with QuirkMatch.
+     */
+    rDim?: string;
+};
+
+/** Content that is tagged for adding enrichment score when triggered by behavior (i.e. being shown that content) */
+type BehaviorTag = {
+    beh?: EnrichmentData[];
+};
+/** Defines the shape of a personalized content variant */
+type PersonalizedVariant<TCriteria = VariantMatchCriteria> = {
+    /** A unique identifier for this variation */
+    id: string;
+    /** Match criteria for this variation */
+    pz?: TCriteria;
+};
+/** The result of computing personalized content from variations */
+type PersonalizedResult<TVariant> = {
+    /** Whether or not this result contains a personalized result */
+    personalized: boolean;
+    /** Matching variations */
+    variations: Array<TVariant & {
+        /** Whether the visitor is part of this variation's local control group (also true if part of global control group) */
+        control: boolean;
+    }>;
+};
+/** Defines the shape of a A/B test variant */
+type TestVariant = {
+    /** The identifier for this variant. This value persisted to storage when a variant is selected. */
+    id: string;
+    /**
+     * A number between 0 and 100 representing what percentage of visitors will be selected for this variant.
+     * If not provided, this variant will be selected in equal proportion to other variants without an explicit distribution.
+     */
+    testDistribution?: number;
+    /** Whether this variant is a control variant.
+     * Can be undefined for backward compatibility with older versions of the SDK which were not explicitly setting the control flag.
+     */
+    control?: boolean;
+};
+/** The result of computing an A/B test result */
+type TestResult<TVariant> = {
+    /** The selected variation */
+    result: TVariant | undefined;
+    /**
+     * Whether the test variant was newly assigned to the visitor.
+     * True: variant was assigned to the visitor for the first time.
+     * False: variant was already assigned to the visitor and is being reused.
+     */
+    variantAssigned: boolean;
+};
+interface PersonalizeOptions<TVariant> {
+    /** Name of placement (sent to analytics) */
+    name: string;
+    /** Possible variations to place  */
+    variations: Iterable<TVariant>;
+    /** Maximum number of variants to place (default: 1) */
+    take?: number;
+    /** Name of the personalization selection algorithm to use. Defaults to top-down criteria when not specified. */
+    algorithm?: string;
+    /** Composition metadata where the personalization is being rendered for analytics tracking */
+    compositionMetadata?: CompositionMetadata;
+}
+interface PersonalizationSelectionAlgorithmOptions<TCriteria, TVariant extends PersonalizedVariant<TCriteria> = PersonalizedVariant<TCriteria>> {
+    /** Name of placement (sent to analytics) */
+    name: string;
+    /** Possible variations to place  */
+    variations: Iterable<TVariant>;
+    /** Maximum number of variants to place (default: 1) */
+    take?: number;
+    /** Callback for logging messages */
+    onLogMessage?: (message: LogMessage) => void;
+    /** Context instance */
+    context: Context;
+}
+
+type TestOptions<TVariant extends TestVariant> = {
+    /** The name of the test that is being run, must be included in the manifest. */
+    name: string;
+    /** Variations that are being tested. */
+    variations: TVariant[];
+    /** Composition metadata where the personalization is being rendered for analytics tracking */
+    compositionMetadata?: CompositionMetadata;
+};
+declare const testVariations: <TVariant extends TestVariant>({ name, context, variations, onLogMessage, }: TestOptions<TVariant> & {
+    context: Context;
+    onLogMessage?: (message: LogMessage) => void;
+}) => TestResult<TVariant>;
+
+declare const CONTEXTUAL_EDITING_TEST_NAME = "contextual_editing_test";
+declare const CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID = "contextual_editing_test_selected_variant";
+type PersonalizationSelectionAlgorithm<TCriteria = unknown> = (options: PersonalizationSelectionAlgorithmOptions<TCriteria>) => PersonalizedResult<PersonalizedVariant<TCriteria>>;
+type PersonalizationSelectionAlgorithms<TCriteria = unknown> = Record<string, PersonalizationSelectionAlgorithm<TCriteria>>;
+/**
+ * Defines a plugin for Uniform Context.
+ * The plugin should attach event handlers in its creation function.
+ * @returns A function that detaches any event handlers when called
+ */
+type ContextPlugin = {
+    /** Defines a log drain for the plugin, which all log messages are sent to */
+    logDrain?: LogDrain;
+    /** Initializes the plugin (attach event handlers here if needed) */
+    init?: (context: Context) => () => void;
+    /** Plugin-specific actions to perform when a user is forgotten */
+    forget?: () => Promise<void> | void;
+    /** Plugin-specific actions to perform when the visitor context is updated, second parameter is the recalculated scores after the update */
+    update?: (newData: Partial<ContextState>, recalculatedScores: ScoreVector) => Promise<void> | void;
+    /**
+     * Allows the plugin to register named personalization selection algorithms
+     *
+     * Important: the `default` and `strongestMatch` algorithms are automatically registered.
+     * We strongly advise against replacing these.
+     */
+    personalizationSelectionAlgorithms?: PersonalizationSelectionAlgorithms<any>;
+};
+interface ContextOptions extends Omit<VisitorDataStoreOptions, 'manifest' | 'onServerTransitionScoresReceived'> {
+    /** The Context Manifest to load (from the Context API) */
+    manifest: ManifestV2;
+    /**
+     * Context plugins to load at initialize time.
+     * Plugins that hook to the log event should be added here so that they can catch init-time log message events.
+     *
+     * Note that the Context passed to the plugin is not yet fully initialized, and is intended for event handler attachment
+     * only - don't call scores, update, etc on it. If you need to call these methods immediately, attach your plugin after initialisation.
+     */
+    plugins?: Array<ContextPlugin>;
+    /**
+     * Only show personalizations if the visitor has given consent.
+     * `false (default)`: personalization can run in memory without visitor granting storage consent
+     * `true`: personalization is not run at all unless storage consent is given
+     */
+    requireConsentForPersonalization?: boolean;
+}
+type PersonalizationEventVariantId = {
+    /** The variant ID that was selected */
+    id: string;
+    /** Whether the visitor is part of this variant's local control group (also true if part of global control group) */
+    control: boolean;
+};
+/** Emitted when a personalization runs */
+type PersonalizationEvent = {
+    /** Name of the personalized placement */
+    name: string;
+    /** Selected variant ID(s) */
+    variantIds: PersonalizationEventVariantId[];
+    /** Whether the user was part of the control group (and did not receive any personalization) */
+    control: boolean | undefined;
+    /**
+     * Whether the personalized placement has changed since the last time the placement was evaluated.
+     * True: the placement was evaluated for the first time, or the variant(s) selected changed from last time (e.g. due to a score change that activated a new variant).
+     * False: the variant(s) selected were the same as a previous evaluation of this placement.
+     */
+    changed: boolean;
+    /**
+     * Contains information about the composition that contains personalization wrapper component,
+     * which triggered the personalization event.
+     * Only references top level root composition after pattern resolutions.
+     */
+    compositionMetadata?: CompositionMetadata;
+};
+/** Emitted event when an A/B test runs */
+type TestEvent = {
+    /** Name (public ID) of the A/B test */
+    name: string;
+    /** ID of the variant that was selected */
+    variantId: string | undefined;
+    /**
+     * Whether the variant is part of the control group.
+     */
+    control: boolean;
+    /**
+     * Whether the test variant was newly assigned to the visitor.
+     * True: variant was assigned to the visitor for the first time.
+     * False: variant was already assigned to the visitor and is being reused.
+     */
+    variantAssigned: boolean;
+    /**
+     * Contains information about the composition that contains A/B test wrapper component,
+     * which triggered the A/B test event.
+     * Only references top level root composition after pattern resolutions.
+     */
+    compositionMetadata?: CompositionMetadata;
+};
+type ContextEvents = {
+    /**
+     * Fired when the scores are updated.
+     * The event is NOT fired if an update does not result in any score changes.
+     * The result is merged between session and permanent data.
+     */
+    scoresUpdated: Readonly<ScoreVector>;
+    /**
+     * Fired when quirk data changes. Not fired if no changes to quirks are made
+     * (e.g. setting it to the same value it already has)
+     */
+    quirksUpdated: Quirks;
+    /**
+     * Fired when a log message is emitted from Context
+     * Note that event handlers attached to this event will not catch events
+     * logged during initialisation of the Context unless they are attached as plugins to the constructor.
+     */
+    log: LogMessage | LogMessageGroup;
+    /** Test variant has been selected */
+    testResult: TestEvent;
+    /** Personalization variants have been selected */
+    personalizationResult: PersonalizationEvent;
+    /** Composition metadata has been set/updated, usually happens when new composition is being rendered during client-side navigation for example */
+    canvasDataUpdated: CompositionMetadata;
+};
+interface ContextInstance {
+    get scores(): Readonly<ScoreVector>;
+    get quirks(): Readonly<Quirks>;
+    update(newData: Partial<ContextState>): Promise<void>;
+    getTestVariantId(testName: string): string | null | undefined;
+    setTestVariantId(testName: string, variantId: string): void;
+    log(...message: LogMessage): void;
+    test<TVariant extends TestVariant>(options: TestOptions<TVariant>): TestResult<TVariant>;
+    personalize<TVariant extends PersonalizedVariant<any>>(options: PersonalizeOptions<TVariant>): PersonalizedResult<TVariant>;
+    forget(fromAllDevices: boolean): Promise<void>;
+    getServerToClientTransitionState(): ServerToClientTransitionState;
+    readonly manifest: ManifestInstance;
+    events: {
+        on: Emitter<ContextEvents>['on'];
+        off: Emitter<ContextEvents>['off'];
+    };
+    /** @deprecated */
+    internal_processTestEvent(event: TestEvent): void;
+    /** @deprecated */
+    internal_processPersonalizationEvent(event: PersonalizationEvent): void;
+    /**
+     * Gets the current canvas data
+     */
+    getCompositionMetadata(): Readonly<CompositionMetadata | undefined>;
+    /**
+     * Updates the canvas data and emits a canvasDataUpdated event
+     */
+    updateCompositionMetadata(newData: CompositionMetadata): Promise<void>;
+}
+declare class Context implements ContextInstance {
+    #private;
+    readonly manifest: ManifestInstance;
+    constructor(options: ContextOptions);
+    /** Gets the current visitor's dimension score vector. */
+    get scores(): Readonly<ScoreVector>;
+    /** Gets the current visitor's quirks values. */
+    get quirks(): Readonly<Quirks>;
+    get requireConsentForPersonalization(): boolean | undefined;
+    /**
+     * Subscribe to events
+     */
+    readonly events: {
+        on: {
+            <Key extends keyof ContextEvents>(type: Key, handler: mitt.Handler<ContextEvents[Key]>): void;
+            (type: "*", handler: mitt.WildcardHandler<ContextEvents>): void;
+        };
+        off: {
+            <Key extends keyof ContextEvents>(type: Key, handler?: mitt.Handler<ContextEvents[Key]> | undefined): void;
+            (type: "*", handler: mitt.WildcardHandler<ContextEvents>): void;
+        };
+    };
+    readonly storage: VisitorDataStore;
+    /**
+     * Updates the Context with new data of any sort, such as
+     * new URLs, cookies, quirks, and enrichments.
+     *
+     * Only properties that are set in the data parameter will be updated,
+     * for example if passing `url` but not `cookies`, the last known state of cookies will be preserved.
+     *
+     * Properties that do not result in a changed state,
+     * i.e. pushing the same URL or cookies as before,
+     * will NOT result in a recomputation of signal state.
+     */
+    update(newData: Partial<ContextState>): Promise<void>;
+    processServerCommands({ serverCommands, commands, }: {
+        serverCommands: StorageCommands[] | undefined;
+        commands: StorageCommands[];
+    }): Promise<void>;
+    /** use test() instead */
+    getTestVariantId(testName: string): string | null | undefined;
+    /** use test() instead */
+    setTestVariantId(testName: string, variantId: string): void;
+    getPersonalizeVariantControl(name: string, index: number): boolean | undefined;
+    /**
+     * Writes a message to the Context log sink.
+     * Used by Uniform internal SDK; not intended for public use.
+     */
+    log(...message: LogMessage): void;
+    /** Executes an A/B test with a given set of variants, showing the visitor's assigned variant (or selecting one to assign, if none is set yet) */
+    test<TVariant extends TestVariant>(options: TestOptions<TVariant>): TestResult<TVariant>;
+    /** Executes a personalized placement with a given set of variants */
+    personalize<TVariant extends PersonalizedVariant<any>>(options: PersonalizeOptions<TVariant>): PersonalizedResult<TVariant>;
+    /**
+     * Forgets the visitor's data and resets the Context to its initial state.
+     * @param fromAllDevices for an identified user, whether to delete all their data (for the entire account) - true, or data for this device (sign out) - false
+     */
+    forget(fromAllDevices: boolean): Promise<void>;
+    /**
+     * Computes server to client transition state.
+     *
+     * Removes state from server-to-client if it came in initial state (cookies) to avoid double tracking on the client.
+     */
+    getServerToClientTransitionState(): ServerToClientTransitionState;
+    /** @deprecated */
+    internal_processTestEvent(event: TestEvent): void;
+    /** @deprecated */
+    internal_processPersonalizationEvent(event: PersonalizationEvent): void;
+    /**
+     * Gets the current canvas data
+     */
+    getCompositionMetadata(): Readonly<CompositionMetadata | undefined>;
+    /**
+     * Updates the canvas data and emits a canvasDataUpdated event
+     */
+    updateCompositionMetadata(newData: CompositionMetadata): Promise<void>;
+}
+
+/**
+ * The version of the DevTools UI to load when in Chromium extension context.
+ * 1: Uniform Optimize.
+ * 2: Uniform Context.
+ */
+type DevToolsUiVersion = 1 | 2;
+/**
+ * The data state provided to the devtools for rendering.
+ */
+type DevToolsState = {
+    /** Current computed visitor scores (includes aggregates) */
+    scores: Readonly<ScoreVector>;
+    /** Current visitor data (includes quirks, raw scores, tests, consent, etc) */
+    data: Readonly<VisitorData>;
+    /** Personalization events that have fired since devtools started */
+    personalizations: Array<PersonalizationEvent>;
+    /** Test events that have fired since devtools started */
+    tests: Array<TestEvent>;
+    /** The Context manifest */
+    manifest: ManifestV2;
+};
+/** Mutations the DevTools can take on the data it receives */
+type DevToolsActions = {
+    /** Standard updates; maps to Context.update() */
+    update: (newData: Partial<ContextState>) => Promise<void>;
+    /** Raw updates to the storage subsystem. Maps to Context.storage.updateData() */
+    rawUpdate: (commands: StorageCommands[]) => Promise<void>;
+    /** Forget the current visitor and clear data on this device */
+    forget: () => Promise<void>;
+};
+type DevToolsEvent<Type extends string = string, TEventData = unknown> = {
+    /** The integration ID that is required */
+    type: Type;
+} & TEventData;
+type DevToolsEvents = DevToolsLogEvent | DevToolsDataEvent | DevToolsHelloEvent | DevToolsUpdateEvent | DevToolsRawCommandsEvent | DevToolsForgetEvent;
+/** A log message emitted as an event to the browser extension */
+type DevToolsLogEvent = DevToolsEvent<'uniform:context:log', {
+    message: LogMessage;
+}>;
+/** Emitted when data is updated in Context to the devtools */
+type DevToolsDataEvent = DevToolsEvent<'uniform:context:data', {
+    data: DevToolsState;
+}>;
+/** A hello message emitted as an event from the browser extension to test if the page contains Context */
+type DevToolsHelloEvent = DevToolsEvent<'uniform:context:hello', {
+    uiVersion: DevToolsUiVersion;
+}>;
+/** Devtools requests a normal update cycle (regular data update, re-eval signals, etc) */
+type DevToolsUpdateEvent = DevToolsEvent<'uniform-in:context:update', {
+    newData: Partial<ContextState>;
+}>;
+/** Devtools requests a raw update cycle (explicitly set scores of dimensions in durations, etc) */
+type DevToolsRawCommandsEvent = DevToolsEvent<'uniform-in:context:commands', {
+    commands: StorageCommands[];
+}>;
+/** A request to forget me from the DevTools */
+type DevToolsForgetEvent = DevToolsEvent<'uniform-in:context:forget', unknown>;
+declare global {
+    interface Window {
+        /** Window var set by enableContextDevTools() to enable embedded devtools to receive Context instance and attach events to it. */
+        __UNIFORM_DEVTOOLS_CONTEXT_INSTANCE__?: Context;
+        /**
+         * Window var set automatically that Uniform's contextual editing uses to respond to changes in the Context within its preview pane,
+         * for example quirks being set from within the preview.
+         */
+        __UNIFORM_CONTEXTUAL_EDITING_CONTEXT__?: Context;
+    }
+}
+
+export { type ManifestV2 as $, type AggregateDimension as A, type DevToolsLogEvent as B, type ContextPlugin as C, type DecayFunction as D, type DevToolsDataEvent as E, type DevToolsHelloEvent as F, type DevToolsUpdateEvent as G, type DevToolsRawCommandsEvent as H, type DevToolsForgetEvent as I, type LogMessages as J, type Severity as K, type LogDrain as L, type MessageCategory as M, type MessageFunc as N, type OutputSeverity as O, type PersonalizedVariant as P, type Quirks as Q, type LogMessageSingle as R, type ScoreVector as S, TransitionDataStore as T, type LogMessageGroup as U, type VisitorData as V, ManifestInstance as W, GroupCriteriaEvaluator as X, type CriteriaEvaluatorResult as Y, type CriteriaEvaluatorParameters as Z, type SignalData as _, type StorageCommands as a, type PersonalizationManifest as a0, type Signal as a1, type SignalCriteriaGroup as a2, type SignalCriteria as a3, type EnrichmentCategory as a4, type NumberMatch as a5, type TestDefinition as a6, type AggregateDimensionInput as a7, type TestOptions as a8, testVariations as a9, type EnrichmentData as aA, type PersonalizeControlVariant as aB, type PersonalizeVariants as aC, type EventData as aD, emptyVisitorData as aE, type CompositionMetadata as aF, type ContextState as aG, type ContextStateUpdate as aH, type GoalStateUpdate as aI, type paths as aJ, type VariationMatchMetadata as aa, type DimensionMatch as ab, type QuirkMatch as ac, type BehaviorTag as ad, type TestVariant as ae, type TestResult as af, type StorageCommand as ag, type SetGoalCommand as ah, type ModifyScoreCommand as ai, type ModifySessionScoreCommand as aj, type SetConsentCommand as ak, type SetQuirkCommand as al, type SetTestCommand as am, type IdentifyCommand as an, type SetControlGroupCommand as ao, type SetPersonalizeVariantControlCommand as ap, areCommandsEqual as aq, type ServerToClientTransitionState as ar, SERVER_STATE_ID as as, type TransitionDataStoreEvents as at, type DecayOptions as au, type VisitorDataStoreOptions as av, type VisitorDataStoreEvents as aw, VisitorDataStore as ax, type Tests as ay, type Goals as az, type TransitionDataStoreOptions as b, type CriteriaEvaluator as c, type StringMatch as d, type VariantMatchCriteria as e, type LogMessage as f, type PersonalizeOptions as g, Context as h, type PersonalizedResult as i, type VariationMatchDimensionCriteria as j, type PersonalizationSelectionAlgorithmOptions as k, type DevToolsEvents as l, CONTEXTUAL_EDITING_TEST_NAME as m, CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID as n, type PersonalizationSelectionAlgorithm as o, type PersonalizationSelectionAlgorithms as p, type ContextOptions as q, type PersonalizationEventVariantId as r, type PersonalizationEvent as s, type TestEvent as t, type ContextEvents as u, type ContextInstance as v, type DevToolsUiVersion as w, type DevToolsState as x, type DevToolsActions as y, type DevToolsEvent as z };