@uniformdev/context 12.2.1-alpha.171 → 12.2.1-alpha.184

package/dist/index.d.ts

@@ -1,186 +1,6 @@
-import { c as components, e as external } from './v2-manifest.swagger-d0899723';
-import * as mitt from 'mitt';
-
-declare 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 */
-declare type StorageCommands = ModifyScoreCommand | ModifySessionScoreCommand | SetConsentCommand | SetQuirkCommand | SetTestCommand | IdentifyCommand;
-/**
- * Changes the visitor's permanent score for a given dimension
- */
-declare type ModifyScoreCommand = StorageCommand<'modscore', {
-    dimension: string;
-    delta: number;
-}>;
-/**
- * Changes the visitor's session (time-based) score for a given dimension
- */
-declare 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.
- */
-declare type SetConsentCommand = StorageCommand<'consent', boolean>;
-/** Sets a permanent quirk key and value for the visitor */
-declare type SetQuirkCommand = StorageCommand<'setquirk', {
-    key: string;
-    value: string;
-}>;
-/** Sets a specific variant as being this visitor's variant on an A/B test */
-declare 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.
- */
-declare type IdentifyCommand = StorageCommand<'identify', {
-    identity: string;
-}>;
-
-declare type Quirks = {
-    [key: string]: string;
-};
-declare type Tests = {
-    [key: string]: string;
-};
-declare type ScoreVector = {
-    [key: string]: number;
-};
-declare type EnrichmentData = {
-    /** Enrichment category name */
-    cat: string;
-    /** Enrichment key value */
-    key: string;
-    /** Strength value (amount of score added when viewing content) */
-    str: number;
-};
-declare type EventData = {
-    event: string;
-    payload?: any;
-};
-declare type VisitorData = {
-    /** Quirk key-value data */
-    quirks: Quirks;
-    /** A/B test variant selections */
-    tests: Tests;
-    /** Personalization score data for the current session (merge with all time for totals) */
-    sessionScores: ScoreVector;
-    /** Personalization score data for all time (merge with session for totals) */
-    scores: ScoreVector;
-    /**
-     * 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;
-};
-declare const emptyVisitorData: () => VisitorData;
-declare type ContextState = {
-    cookies: Record<string, string>;
-    url: URL;
-    quirks: Quirks;
-    enrichments: EnrichmentData[];
-    events: EventData[];
-};
-declare type ContextStateUpdate = {
-    state: Partial<ContextState>;
-    previousState: Partial<ContextState>;
-    visitor: VisitorData;
-    scores: ScoreVector;
-};
-
-declare type TransitionDataStoreOptions = {
-    initialData?: Partial<VisitorData>;
-};
-declare type ServerToClientTransitionState = Pick<Partial<VisitorData>, 'quirks' | 'tests'> & {
-    /**
-     * 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;
-};
-declare const SERVER_STATE_ID = "__UNIFORM_DATA__";
-declare 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;
-    /**
-     * 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_1 extends "dataUpdatedAsync">(type: Key_1, handler?: mitt.Handler<TransitionDataStoreEvents[Key_1]> | 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;
-}
+import { C as CookieAdapter, T as TransitionDataStore, S as StorageCommands, V as VisitorData, a as TransitionDataStoreOptions, D as DecayFunction, O as OutputSeverity, L as LogDrain, b as ContextPlugin, c as CriteriaEvaluator, d as StringMatch, e as ScoreVector, A as AggregateDimension, f as VariantMatchCriteria } from './types-1ad8439c';
+export { A as AggregateDimension, l as AggregateDimensionInput, a7 as BehaviorTag, Z as Context, Y as ContextEvents, U as ContextOptions, b as ContextPlugin, q as ContextState, r as ContextStateUpdate, C as CookieAdapter, c as CriteriaEvaluator, D as DecayFunction, z as DecayOptions, af as DevToolsActions, aj as DevToolsDataEvent, ag as DevToolsEvent, ah as DevToolsEvents, an as DevToolsForgetEvent, ak as DevToolsHelloEvent, ai as DevToolsLogEvent, am as DevToolsRawCommandsEvent, ae as DevToolsState, ad as DevToolsUiVersion, al as DevToolsUpdateEvent, a6 as DimensionMatch, E as EnrichmentCategory, n as EnrichmentData, o as EventData, G as GroupCriteriaEvaluator, I as IdentifyCommand, L as LogDrain, a1 as LogMessage, _ as LogMessages, M as ManifestInstance, g as ManifestV2, a0 as MessageFunc, t as ModifyScoreCommand, u as ModifySessionScoreCommand, N as NumberMatch, O as OutputSeverity, W as PersonalizationEvent, P as PersonalizationManifest, a4 as PersonalizeOptions, a9 as PersonalizedResult, a8 as PersonalizedVariant, Q as Quirks, K as SERVER_STATE_ID, e as ScoreVector, J as ServerToClientTransitionState, v as SetConsentCommand, y as SetControlGroupCommand, w as SetQuirkCommand, x as SetTestCommand, $ as Severity, h as Signal, j as SignalCriteria, i as SignalCriteriaGroup, s as StorageCommand, S as StorageCommands, d as StringMatch, ac as TaggedContent, k as TestDefinition, X as TestEvent, a3 as TestOptions, ab as TestResult, aa as TestVariant, m as Tests, T as TransitionDataStore, R as TransitionDataStoreEvents, a as TransitionDataStoreOptions, f as VariantMatchCriteria, V as VisitorData, H as VisitorDataStore, F as VisitorDataStoreEvents, B as VisitorDataStoreOptions, p as emptyVisitorData, a5 as personalizeVariations, a2 as testVariations } from './types-1ad8439c';
+import 'mitt';
 
 declare type CookieTransitionDataStoreOptions = {
     cookieAdapter: CookieAdapter;
@@ -230,26 +50,6 @@ declare type LinearDecayOptions = {
  */
 declare function createLinearDecay(options?: LinearDecayOptions): DecayFunction;
 
-declare type CookieAdapter = {
-    get: (name: string) => string | undefined;
-    set: (name: string, value: string) => void;
-    remove: (name: string) => void;
-};
-declare type DecayOptions = {
-    now: number;
-    lastUpd: number | undefined;
-    scores: ScoreVector;
-    sessionScores: ScoreVector;
-};
-/**
- * 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
- */
-declare type DecayFunction = (options: DecayOptions) => boolean;
-
 /**
  * Creates a new log drain that will log to the console.
  * The log drain will only log event IDs, but is much smaller than the
@@ -264,59 +64,6 @@ declare function createConsoleLogDrain(level: OutputSeverity): LogDrain;
  */
 declare function enableConsoleLogDrain(level: OutputSeverity): ContextPlugin;
 
-/** Defines all error codes and their parameter(s)  */
-declare 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>;
-    /** Storage received update commands */
-    101: MessageFunc<StorageCommands[]>;
-    /** Storage data was updated */
-    102: MessageFunc<VisitorData>;
-    /** Storage data was deleted bool: fromAllDevices */
-    103: 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<ScoreVector>;
-    /** Placement does not have a name */
-    301: MessageFunc;
-    /** Test did not exist */
-    401: MessageFunc<string>;
-    /** Previously shown test variant no longer in variant data */
-    402: MessageFunc<{
-        test: string;
-        variant: string;
-    }>;
-    /** gtag was not present on the page to emit events to */
-    700: MessageFunc;
-    /** Enabled gtag event signal redirection */
-    701: MessageFunc;
-};
-
-declare type Severity = 'debug' | 'info' | 'warn' | 'error';
-declare type OutputSeverity = Severity | 'none';
-declare type MessageFunc<TArg = void> = (arg: TArg) => [string, string, ...any];
-declare type LogMessage<TID extends keyof LogMessages = keyof LogMessages> = [
-    severity: Severity,
-    id: TID,
-    ...args: Parameters<LogMessages[TID]>
-];
-declare type LogDrain = (message: LogMessage) => void;
-
 /**
  * Creates a new log drain that will log full debug messages to the console.
  * The debug log drain adds significant bundle size, but is useful for debugging.
@@ -330,118 +77,6 @@ declare function createDebugConsoleLogDrain(level: OutputSeverity): LogDrain;
  */
 declare function enableDebugConsoleLogDrain(level: OutputSeverity): ContextPlugin;
 
-declare 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.
-     */
-    onServerTransitionScoresReceived?: (ssv: ScoreVector) => void;
-    /** Called when a log message is emitted from the data store */
-    onLogMessage?: (message: LogMessage) => void;
-};
-declare 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'>;
-};
-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;
-    /**
-     * 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_1 extends keyof VisitorDataStoreEvents>(type: Key_1, handler?: mitt.Handler<VisitorDataStoreEvents[Key_1]> | 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, }: {
-        manifest: ManifestV2;
-        evaluator?: GroupCriteriaEvaluator;
-    });
-    rollForControlGroup(): boolean;
-    getTest(name: string): TestDefinition | undefined;
-    computeSignals(update: ContextStateUpdate): StorageCommands[];
-    /**
-     * Computes aggregated scores based on other dimensions
-     */
-    computeAggregateDimensions(primitiveScores: ScoreVector): ScoreVector;
-    getDimensionByKey(scoreKey: string): EnrichmentCategory | Signal | undefined;
-}
-
-declare type SharedTypes = external['uniform-context-types.swagger.yml']['components']['schemas'];
-declare type ManifestV2 = components['schemas']['ManifestV2'];
-declare type PersonalizationManifest = components['schemas']['PersonalizationManifest'];
-declare type Signal = SharedTypes['Signal'];
-declare type SignalCriteriaGroup = SharedTypes['SignalCriteriaGroup'];
-declare type SignalCriteria = SharedTypes['SignalCriteria'];
-declare type EnrichmentCategory = SharedTypes['EnrichmentCategory'];
-declare type StringMatch = SharedTypes['StringMatch'];
-declare type NumberMatch = SharedTypes['NumberMatch'];
-declare type TestDefinition = SharedTypes['Test'];
-declare type AggregateDimension = SharedTypes['AggregateDimension'];
-declare type AggregateDimensionInput = SharedTypes['AggregateDimensionInput'];
-
 declare const cookieEvaluator: CriteriaEvaluator;
 
 declare const pageViewCountDimension: string;
@@ -455,19 +90,6 @@ declare const eventEvaluator: CriteriaEvaluator;
 
 declare const pageVisitedEvaluator: CriteriaEvaluator;
 
-/**
- * A type that evaluates a signal criteria type and
- * decides if it matches the current Context state or not.
- * @returns {boolean} - true for a match, false for no match
- * */
-declare type CriteriaEvaluator = (update: ContextStateUpdate, criteria: SignalCriteria, commands: StorageCommands[], signal: Signal, dimension: string) => boolean;
-
-declare class GroupCriteriaEvaluator {
-    #private;
-    constructor(criteriaEvaluators: Record<string, CriteriaEvaluator>);
-    evaluate(update: ContextStateUpdate, crit: SignalCriteriaGroup, commands: StorageCommands[], signal: Signal, dimension: string): boolean;
-}
-
 /** Tests if a StringMatch matches a string value */
 declare function isStringMatch(lhs: string | null | undefined, match: StringMatch): boolean;
 
@@ -476,236 +98,8 @@ declare function computeAggregateDimensions(primitiveScores: ScoreVector, aggreg
 
 declare function getEnrichmentVectorKey(category: string, value: string): string;
 
-/** Content that is tagged for adding enrichment score when triggered by behavior (i.e. being shown that content) */
-declare type BehaviorTag = {
-    beh?: EnrichmentData[];
-};
-/** Defines the shape of a personalized content variant */
-declare type PersonalizedVariant = {
-    /** A unique identifier for this variation */
-    id: string;
-    /** Match criteria for this variation */
-    pz?: VariantMatchCriteria;
-};
-/** The result of computing personalized content from variations */
-declare type PersonalizedResult<TVariant> = {
-    /** Whether or not this result contains a personalized result */
-    personalized: boolean;
-    /** Matching variations */
-    variations: Array<TVariant>;
-};
-/** Defines the shape of a A/B test variant */
-declare 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;
-};
-/** The result of computing an A/B test result */
-declare type TestResult<TVariant> = {
-    /** The selected variation */
-    result: TVariant | undefined;
-};
-/** Defines the shape of arbitrarily tagged content where the tag can be for a test, behaviour, or personalization */
-declare type TaggedContent = PersonalizedVariant & TestVariant & BehaviorTag & {
-    /** @deprecated no longer used */
-    intents?: IntentTagVector;
-};
-/**
- * A vector keyed by intent ID which contains magnitude and configuration data for each intent ID that has been tagged
- * @deprecated no longer used
- */
-declare type IntentTagVector = Record<string, IntentTagAxis>;
-/**
- * An individual intent tag magnitude value in an IntentTagVector
- * @deprecated no longer used
- */
-interface IntentTagAxis {
-    /** If this is true, don't use this intent tag when calculating personalization. If false or unspecified, personalization is allowed. */
-    noPn?: boolean;
-    /** If this is true, don't use this intent tag when calculating behavior. If false or unspecified, behavior is allowed. */
-    noBeh?: boolean;
-    /**
-     * If this is true, ANY strength in the tagged intent will result in selecting this variant to personalize,
-     * regardless of other intents' strengths. If more than one tag is override,
-     * they are sorted normally.
-     */
-    override?: boolean;
-    /**
-     * Sets the minimum visitor score required to trigger this variation.
-     * If more than one intent tag matches, the one with the highest threshold will win.
-     */
-    threshold?: number;
-    /** Strength of the intent tag. If unspecified, IntentTagStrength.Normal should be inferred */
-    str?: number | string;
-}
-
-declare type PersonalizeOptions<TVariant> = {
-    /** Name of placement */
-    name?: string;
-    /** Possible variants to place  */
-    variations: Iterable<TVariant>;
-    /** Maximum number of variants to place (default: 1) */
-    take?: number;
-};
-declare function personalizeVariations<TVariant extends PersonalizedVariant>({ context, variations, take, }: PersonalizeOptions<TVariant> & {
-    context: Context;
-}): PersonalizedResult<TVariant>;
-
 declare function evaluateVariantMatch(match: VariantMatchCriteria | undefined | null, vec: ScoreVector): boolean;
 
-declare type VariantMatchCriteria = {
-    /**
-     * Operation for match criteria
-     *
-     * @defaultValue `&`
-     */
-    op?: '&' | '|';
-    crit: DimensionMatch[];
-};
-declare 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
-     * -: `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;
-};
-
-declare 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[];
-};
-declare const testVariations: <TVariant extends TestVariant>({ name, context, variations, }: TestOptions<TVariant> & {
-    context: Context;
-}) => TestResult<TVariant>;
-
-/**
- * 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
- */
-declare type ContextPlugin = {
-    logDrain?: LogDrain;
-    init?: (context: Context) => () => void;
-};
-declare type ContextOptions = {
-    /** 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>;
-} & Omit<VisitorDataStoreOptions, 'manifest' | 'onServerTransitionScoresReceived'>;
-declare type PersonalizationEvent = {
-    name: string;
-    variantIds: string[];
-    control: boolean | undefined;
-};
-declare type TestEvent = {
-    name: string;
-    variantId: string | undefined;
-    control: boolean | undefined;
-};
-declare 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;
-    /** Test variant has been selected */
-    testResult: TestEvent;
-    /** Personalization variants have been selected */
-    personalizationResult: PersonalizationEvent;
-};
-declare class Context implements Context {
-    #private;
-    readonly manifest: ManifestInstance;
-    constructor(options: ContextOptions);
-    get scores(): Readonly<ScoreVector>;
-    /**
-     * 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_1 extends keyof ContextEvents>(type: Key_1, handler?: mitt.Handler<ContextEvents[Key_1]> | undefined): void;
-            (type: "*", handler: mitt.WildcardHandler<ContextEvents>): void;
-        };
-    };
-    readonly storage: VisitorDataStore;
-    update(newData: Partial<ContextState>): Promise<void>;
-    getTestVariantId(testName: string): string | null | undefined;
-    setTestVariantId(testName: string, variantId: string): void;
-    /**
-     * 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>(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>;
-}
-
 declare enum ScriptType {
     ListStart = "nesi-list-start",
     ListEnd = "nesi-list-end",
@@ -723,70 +117,6 @@ declare type EdgeTestComponentOptions = {
 };
 declare const EdgeNodeTagName = "nesitag";
 
-/**
- * The version of the DevTools UI to load when in Chromium extension context.
- * 1: Uniform Optimize.
- * 2: Uniform Context.
- */
-declare type DevToolsUiVersion = 1 | 2;
-/**
- * The data state provided to the devtools for rendering.
- */
-declare 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 */
-declare 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>;
-};
-declare type DevToolsEvent<Type extends string = string, TEventData = unknown> = {
-    /** The integration ID that is required */
-    type: Type;
-} & TEventData;
-declare type DevToolsEvents = DevToolsLogEvent | DevToolsDataEvent | DevToolsHelloEvent | DevToolsUpdateEvent | DevToolsRawCommandsEvent | DevToolsForgetEvent;
-/** A log message emitted as an event to the browser extension */
-declare type DevToolsLogEvent = DevToolsEvent<'uniform:context:log', {
-    message: LogMessage;
-}>;
-/** Emitted when data is updated in Context to the devtools */
-declare 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 */
-declare type DevToolsHelloEvent = DevToolsEvent<'uniform:context:hello', {
-    uiVersion: DevToolsUiVersion;
-}>;
-/** Devtools requests a normal update cycle (regular data update, re-eval signals, etc) */
-declare type DevToolsUpdateEvent = DevToolsEvent<'uniform-in:context:update', {
-    newData: Partial<ContextState>;
-}>;
-/** Devtools requests a raw update cycle (explicitly set scores of dimensions in durations, etc) */
-declare type DevToolsRawCommandsEvent = DevToolsEvent<'uniform-in:context:commands', {
-    commands: StorageCommands[];
-}>;
-/** A request to forget me from the DevTools */
-declare 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;
-    }
-}
-
 /**
  * Enables a Context instance to feed data to the Uniform Context DevTools.
  * DevTools can be hosted either as a Chromium extension, or as a standalone
@@ -795,4 +125,4 @@ declare global {
  */
 declare function enableContextDevTools(): ContextPlugin;
 
-export { AggregateDimension, AggregateDimensionInput, BehaviorTag, Context, ContextEvents, ContextOptions, ContextPlugin, ContextState, ContextStateUpdate, CookieAdapter, CookieTransitionDataStore, CookieTransitionDataStoreOptions, CriteriaEvaluator, DecayFunction, DecayOptions, DevToolsActions, DevToolsDataEvent, DevToolsEvent, DevToolsEvents, DevToolsForgetEvent, DevToolsHelloEvent, DevToolsLogEvent, DevToolsRawCommandsEvent, DevToolsState, DevToolsUiVersion, DevToolsUpdateEvent, DimensionMatch, EdgeNodeTagName, EdgePersonalizeComponentOptions, EdgeTestComponentOptions, EdgeTransitionDataStore, EdgeTransitionDataStoreOptions, EnrichmentCategory, EnrichmentData, EventData, GroupCriteriaEvaluator, IdentifyCommand, LinearDecayOptions, LogDrain, LogMessage, LogMessages, ManifestInstance, ManifestV2, MessageFunc, ModifyScoreCommand, ModifySessionScoreCommand, NumberMatch, OutputSeverity, PersonalizationEvent, PersonalizationManifest, PersonalizeOptions, PersonalizedResult, PersonalizedVariant, Quirks, SERVER_STATE_ID, ScoreVector, ScriptType, ServerToClientTransitionState, SetConsentCommand, SetQuirkCommand, SetTestCommand, Severity, Signal, SignalCriteria, SignalCriteriaGroup, StorageCommand, StorageCommands, StringMatch, TaggedContent, TestDefinition, TestEvent, TestOptions, TestResult, TestVariant, Tests, TransitionDataStore, TransitionDataStoreEvents, TransitionDataStoreOptions, VariantMatchCriteria, VisitorData, VisitorDataStore, VisitorDataStoreEvents, VisitorDataStoreOptions, computeAggregateDimensions, cookieEvaluator, createConsoleLogDrain, createDebugConsoleLogDrain, createLinearDecay, emptyVisitorData, enableConsoleLogDrain, enableContextDevTools, enableDebugConsoleLogDrain, evaluateVariantMatch, eventEvaluator, getEnrichmentVectorKey, isStringMatch, pageViewCountDimension, pageViewCountEvaluator, pageVisitedEvaluator, personalizeVariations, queryStringEvaluator, quirkEvaluator, testVariations };
+export { CookieTransitionDataStore, CookieTransitionDataStoreOptions, EdgeNodeTagName, EdgePersonalizeComponentOptions, EdgeTestComponentOptions, EdgeTransitionDataStore, EdgeTransitionDataStoreOptions, LinearDecayOptions, ScriptType, computeAggregateDimensions, cookieEvaluator, createConsoleLogDrain, createDebugConsoleLogDrain, createLinearDecay, enableConsoleLogDrain, enableContextDevTools, enableDebugConsoleLogDrain, evaluateVariantMatch, eventEvaluator, getEnrichmentVectorKey, isStringMatch, pageViewCountDimension, pageViewCountEvaluator, pageVisitedEvaluator, queryStringEvaluator, quirkEvaluator };