@contentful/optimization-core 0.1.0-alpha10 → 0.1.0-alpha12

package/dist/index.d.cts

@@ -1,378 +1,62 @@
 /**
- * Optimization Core SDK — platform-agnostic personalization and analytics.
+ * Optimization Core SDK — platform-agnostic optimization and analytics.
  *
  * @packageDocumentation
  */
 
 import { ApiClient } from '@contentful/optimization-api-client';
 import { ApiClientConfig } from '@contentful/optimization-api-client';
+import { App } from '@contentful/optimization-api-client/api-schemas';
 import { batch } from '@preact/signals-core';
+import { BatchInsightsEventArray } from '@contentful/optimization-api-client/api-schemas';
 import type { ChainModifiers } from 'contentful';
-import { ChangeArray } from '@contentful/optimization-api-client/api-schemas';
-import { ComponentClickBuilderArgs } from '@contentful/optimization-api-client';
-import { ComponentHoverBuilderArgs } from '@contentful/optimization-api-client';
-import { ComponentViewBuilderArgs } from '@contentful/optimization-api-client';
+import type { ChangeArray } from '@contentful/optimization-api-client/api-schemas';
+import { Channel } from '@contentful/optimization-api-client/api-schemas';
+import { ClickEvent } from '@contentful/optimization-api-client/api-schemas';
 import { computed } from '@preact/signals-core';
 import { effect } from '@preact/signals-core';
 import type { Entry } from 'contentful';
 import { EntryReplacementVariant } from '@contentful/optimization-api-schemas';
 import { EntryReplacementVariant as EntryReplacementVariant_2 } from '@contentful/optimization-api-client/api-schemas';
 import type { EntrySkeletonType } from 'contentful';
-import { EventBuilder } from '@contentful/optimization-api-client';
-import { EventBuilderConfig } from '@contentful/optimization-api-client';
-import { ExperienceApiClientConfig } from '@contentful/optimization-api-client';
+import type { ExperienceApiClientConfig } from '@contentful/optimization-api-client';
+import type { ExperienceApiClientRequestOptions } from '@contentful/optimization-api-client';
 import { ExperienceEvent } from '@contentful/optimization-api-client/api-schemas';
 import { ExperienceEventArray } from '@contentful/optimization-api-client/api-schemas';
 import type { ExperienceEventType } from '@contentful/optimization-api-client/api-schemas';
-import { Flags } from '@contentful/optimization-api-client/api-schemas';
+import { Flags } from '@contentful/optimization-api-schemas';
+import type { Flags as Flags_2 } from '@contentful/optimization-api-client/api-schemas';
 import { GlobalApiConfigProperties } from '@contentful/optimization-api-client';
-import { IdentifyBuilderArgs } from '@contentful/optimization-api-client';
-import { InsightsApiClientConfig } from '@contentful/optimization-api-client';
+import { HoverEvent } from '@contentful/optimization-api-client/api-schemas';
+import { IdentifyEvent } from '@contentful/optimization-api-client/api-schemas';
+import type { InsightsApiClientConfig } from '@contentful/optimization-api-client';
 import { InsightsEvent } from '@contentful/optimization-api-client/api-schemas';
 import type { InsightsEventType } from '@contentful/optimization-api-client/api-schemas';
-import { Json } from '@contentful/optimization-api-client/api-schemas';
+import type { Json } from '@contentful/optimization-api-client/api-schemas';
+import { Library } from '@contentful/optimization-api-client/api-schemas';
 import type { LocaleCode } from 'contentful';
 import type { LogLevels } from '@contentful/optimization-api-client/logger';
-import { MergeTagEntry } from '@contentful/optimization-api-client/api-schemas';
+import type { MergeTagEntry } from '@contentful/optimization-api-client/api-schemas';
 import { OptimizationData } from '@contentful/optimization-api-client/api-schemas';
-import { PageViewBuilderArgs } from '@contentful/optimization-api-client';
+import { OptimizationEntry } from '@contentful/optimization-api-schemas';
+import { OptimizationEntry as OptimizationEntry_2 } from '@contentful/optimization-api-client/api-schemas';
+import { OptimizedEntry } from '@contentful/optimization-api-schemas';
+import { OptimizedEntry as OptimizedEntry_2 } from '@contentful/optimization-api-client/api-schemas';
+import { Page } from '@contentful/optimization-api-client/api-schemas';
+import { PageViewEvent } from '@contentful/optimization-api-client/api-schemas';
 import { PartialProfile } from '@contentful/optimization-api-client/api-schemas';
-import { PersonalizationEntry } from '@contentful/optimization-api-schemas';
-import { PersonalizationEntry as PersonalizationEntry_2 } from '@contentful/optimization-api-client/api-schemas';
-import { PersonalizedEntry } from '@contentful/optimization-api-schemas';
-import { PersonalizedEntry as PersonalizedEntry_2 } from '@contentful/optimization-api-client/api-schemas';
 import { Profile } from '@contentful/optimization-api-client/api-schemas';
 import { ReadonlySignal } from '@preact/signals-core';
-import { ScreenViewBuilderArgs } from '@contentful/optimization-api-client';
-import { SelectedPersonalization } from '@contentful/optimization-api-client/api-schemas';
-import { SelectedPersonalization as SelectedPersonalization_2 } from '@contentful/optimization-api-schemas';
-import { SelectedPersonalizationArray } from '@contentful/optimization-api-client/api-schemas';
+import { ScreenViewEvent } from '@contentful/optimization-api-client/api-schemas';
+import { SelectedOptimization } from '@contentful/optimization-api-schemas';
+import { SelectedOptimization as SelectedOptimization_2 } from '@contentful/optimization-api-client/api-schemas';
+import { SelectedOptimizationArray } from '@contentful/optimization-api-client/api-schemas';
 import { Signal } from '@preact/signals-core';
-import { TrackBuilderArgs } from '@contentful/optimization-api-client';
+import { TrackEvent as TrackEvent_2 } from '@contentful/optimization-api-client/api-schemas';
+import { UniversalEventProperties } from '@contentful/optimization-api-client/api-schemas';
 import { untracked } from '@preact/signals-core';
-
-/**
- * Base class for analytics implementations (internal).
- *
- * @internal
- * @remarks
- * Concrete analytics classes should implement the component/flag view tracking
- * methods below. This base is not part of the public API.
- */
-declare abstract class AnalyticsBase extends ProductBase {
-    /**
-     * Track a UI component view event.
-     *
-     * @param payload - Component view builder arguments.
-     * @returns A promise that resolves when processing is complete (or `void`).
-     */
-    abstract trackComponentView(payload: ComponentViewBuilderArgs): Promise<void> | void;
-    /**
-     * Track a UI component click event.
-     *
-     * @param payload - Component click builder arguments.
-     * @returns A promise that resolves when processing is complete (or `void`).
-     */
-    abstract trackComponentClick(payload: ComponentClickBuilderArgs): Promise<void> | void;
-    /**
-     * Track a UI component hover event.
-     *
-     * @param payload - Component hover builder arguments.
-     * @returns A promise that resolves when processing is complete (or `void`).
-     */
-    abstract trackComponentHover(payload: ComponentHoverBuilderArgs): Promise<void> | void;
-    /**
-     * Track a flag (feature) view event.
-     *
-     * @param payload - Flag view builder arguments.
-     * @returns A promise that resolves when processing is complete (or `void`).
-     */
-    abstract trackFlagView(payload: ComponentViewBuilderArgs): Promise<void> | void;
-}
-
-/**
- * Configuration for the stateful analytics implementation.
- *
- * @public
- */
-export declare interface AnalyticsProductConfig extends ProductConfig {
-    /**
-     * Default signal values applied on initialization.
-     */
-    defaults?: AnalyticsProductConfigDefaults;
-    /**
-     * Policy that controls stateful queue flush retries, backoff, and circuit
-     * behavior after repeated failures.
-     */
-    queuePolicy?: QueueFlushPolicy;
-}
-
-/**
- * Default analytics state values applied at construction time.
- *
- * @public
- */
-export declare interface AnalyticsProductConfigDefaults {
-    /** Whether analytics collection is allowed by default. */
-    consent?: boolean;
-    /** Default profile to associate with events. */
-    profile?: Profile;
-}
-
-/**
- * Analytics implementation that maintains local state (consent, profile) and
- * queues events until flushed or the queue reaches a maximum size.
- *
- * @remarks
- * Repeated flush failures are managed by the configured {@link QueueFlushPolicy}
- * using bounded backoff and a temporary circuit-open window.
- *
- * @public
- */
-export declare class AnalyticsStateful extends AnalyticsBase implements ConsentGuard {
-    /** In-memory queue keyed by stable profile identifier. */
-    private readonly queue;
-    /** Shared queue flush retry runtime state machine. */
-    private readonly flushRuntime;
-    /** Exposed observable state references. */
-    readonly states: AnalyticsStates;
-    /**
-     * Create a new stateful analytics instance.
-     *
-     * @param options - Options to configure the analytics product for stateful environments.
-     * @example
-     * ```ts
-     * const analytics = new AnalyticsStateful({ api, builder, config: { defaults: { consent: true } }, interceptors })
-     * ```
-     */
-    constructor(options: AnalyticsStatefulOptions);
-    /**
-     * Reset analytics‑related signals and the last emitted event.
-     *
-     * @example
-     * ```ts
-     * analytics.reset()
-     * ```
-     */
-    reset(): void;
-    /**
-     * Determine whether the named operation is permitted based on consent and
-     * allowed event type configuration.
-     *
-     * @param name - The method name; component view/flag methods are normalized
-     * to `'component'`, component click methods are normalized to `'component_click'`,
-     * and component hover methods are normalized to `'component_hover'` for
-     * allow‑list checks.
-     * @returns `true` if the operation is permitted; otherwise `false`.
-     * @example
-     * ```ts
-     * if (analytics.hasConsent('track')) { ... }
-     * ```
-     */
-    hasConsent(name: string): boolean;
-    /**
-     * Hook invoked when an operation is blocked due to missing consent.
-     *
-     * @param name - The blocked operation name.
-     * @param payload - The original arguments supplied to the operation.
-     * @example
-     * ```ts
-     * analytics.onBlockedByConsent('track', [payload])
-     * ```
-     */
-    onBlockedByConsent(name: string, payload: readonly unknown[]): void;
-    /**
-     * Queue a component view event for the active profile.
-     *
-     * @param payload - Component view builder arguments.
-     * @returns A promise that resolves when the event has been queued.
-     * @example
-     * ```ts
-     * await analytics.trackComponentView({ componentId: 'hero-banner' })
-     * ```
-     */
-    trackComponentView(payload: ComponentViewBuilderArgs): Promise<void>;
-    /**
-     * Queue a component click event for the active profile.
-     *
-     * @param payload - Component click builder arguments.
-     * @returns A promise that resolves when the event has been queued.
-     * @example
-     * ```ts
-     * await analytics.trackComponentClick({ componentId: 'hero-banner' })
-     * ```
-     */
-    trackComponentClick(payload: ComponentClickBuilderArgs): Promise<void>;
-    /**
-     * Queue a component hover event for the active profile.
-     *
-     * @param payload - Component hover builder arguments.
-     * @returns A promise that resolves when the event has been queued.
-     * @example
-     * ```ts
-     * await analytics.trackComponentHover({ componentId: 'hero-banner' })
-     * ```
-     */
-    trackComponentHover(payload: ComponentHoverBuilderArgs): Promise<void>;
-    /**
-     * Queue a flag view event for the active profile.
-     *
-     * @param payload - Flag view builder arguments.
-     * @returns A promise that resolves when the event has been queued.
-     * @example
-     * ```ts
-     * await analytics.trackFlagView({ componentId: 'feature-flag-123' })
-     * ```
-     */
-    trackFlagView(payload: ComponentViewBuilderArgs): Promise<void>;
-    /**
-     * Intercept, validate, and place an event into the profile‑scoped queue; then
-     * trigger a size‑based flush if necessary.
-     *
-     * @param event - The event to enqueue.
-     */
-    private enqueueEvent;
-    /**
-     * Flush the queue automatically when the total number of queued events
-     * reaches {@link MAX_QUEUED_EVENTS}.
-     */
-    private flushMaxEvents;
-    /**
-     * Send all queued events grouped by profile and clear the queue.
-     *
-     * @param options - Optional flush controls.
-     * @param options.force - When `true`, bypass offline/backoff/circuit gates and attempt immediately.
-     * @remarks Only under rare circumstances should there be more than one
-     * profile in a stateful application.
-     * @example
-     * ```ts
-     * await analytics.flush()
-     * ```
-     */
-    flush(options?: {
-        force?: boolean;
-    }): Promise<void>;
-    /**
-     * Apply default stateful analytics values when provided.
-     *
-     * @param defaults - Optional defaults for analytics state.
-     */
-    private applyDefaults;
-    /**
-     * Initialize reactive effects for consent/profile logging and online flushes.
-     */
-    private initializeEffects;
-    /**
-     * Build batch payloads grouped by profile from the in-memory queue.
-     *
-     * @returns Grouped batch payloads.
-     */
-    private createBatches;
-    /**
-     * Attempt to send queued batches to the Insights API.
-     *
-     * @param batches - Batches to send.
-     * @returns `true` when send succeeds; otherwise `false`.
-     */
-    private trySendBatches;
-    /**
-     * Compute the total number of queued events across all profiles.
-     *
-     * @returns Total queued event count.
-     */
-    private getQueuedEventCount;
-}
-
-/**
- * Options for configuring {@link AnalyticsStateful} functionality.
- *
- * @public
- * @see {@link ProductBaseOptions}
- */
-export declare type AnalyticsStatefulOptions = ProductBaseOptions & {
-    /** Configuration specific to the Analytics product */
-    config?: AnalyticsProductConfig;
-};
-
-/**
- * Stateless analytics implementation that sends each event immediately in a
- * single‑event batch.
- *
- * @public
- */
-export declare class AnalyticsStateless extends AnalyticsBase {
-    /**
-     * Build, intercept, validate, and send a component view event.
-     *
-     * @param args - {@link TrackComponentViewArgs} used to build the event. Includes an
-     * optional partial profile.
-     * @returns A promise that resolves once the batch has been sent.
-     * @example
-     * ```ts
-     * await analytics.trackComponentView({ componentId: 'hero-banner', profile: { id: 'user-1' } })
-     * ```
-     */
-    trackComponentView(args: TrackComponentViewArgs): Promise<void>;
-    /**
-     * Build, intercept, validate, and send a component click event.
-     *
-     * @param args - {@link TrackComponentClickArgs} used to build the event. Includes an
-     * optional partial profile.
-     * @returns A promise that resolves once the batch has been sent.
-     * @example
-     * ```ts
-     * await analytics.trackComponentClick({ componentId: 'hero-banner', profile: { id: 'user-1' } })
-     * ```
-     */
-    trackComponentClick(args: TrackComponentClickArgs): Promise<void>;
-    /**
-     * Build, intercept, validate, and send a component hover event.
-     *
-     * @param args - {@link TrackComponentHoverArgs} used to build the event. Includes an
-     * optional partial profile.
-     * @returns A promise that resolves once the batch has been sent.
-     * @example
-     * ```ts
-     * await analytics.trackComponentHover({ componentId: 'hero-banner', profile: { id: 'user-1' } })
-     * ```
-     */
-    trackComponentHover(args: TrackComponentHoverArgs): Promise<void>;
-    /**
-     * Build, intercept, validate, and send a flag view event.
-     *
-     * @param args - {@link TrackComponentViewArgs} used to build the event. Includes an
-     * optional partial profile.
-     * @returns A promise that resolves once the batch has been sent.
-     * @example
-     * ```ts
-     * await analytics.trackFlagView({ componentId: 'feature-flag-123' })
-     * ```
-     */
-    trackFlagView(args: TrackComponentViewArgs): Promise<void>;
-    /**
-     * Send a single {@link AnalyticsEvent} wrapped in a one‑item batch.
-     *
-     * @param event - The event to send.
-     * @param profile - Optional partial profile to attach to the batch.
-     * @returns A promise that resolves when the API call completes.
-     * @internal
-     */
-    private sendBatchEvent;
-}
-
-/**
- * Observables exposed by the stateful analytics product.
- *
- * @public
- */
-export declare interface AnalyticsStates {
-    /** Observable stream of the latest blocked event payload (or `undefined`). */
-    blockedEventStream: Observable<BlockedEvent | undefined>;
-    /** Observable stream of the latest {@link AnalyticsEvent} or {@link PersonalizationEvent} (or `undefined`). */
-    eventStream: Observable<InsightsEvent | ExperienceEvent | undefined>;
-    /** Observable stream of the active {@link Profile} (or `undefined`). */
-    profile: Observable<Profile | undefined>;
-}
+import { ViewEvent } from '@contentful/optimization-api-client/api-schemas';
+import * as z from 'zod/mini';
 
 /**
  * Anonymous-ID cookie name used by the Optimization Core.
@@ -380,7 +64,7 @@ export declare interface AnalyticsStates {
  * @public
  * @remarks
  * This constant represents the cookie key used by the Optimization Framework
- * to persist an anonymous identifier for tracking personalization and analytics
+ * to persist an anonymous identifier for tracking optimization and insights
  * events when no explicit profile is known.
  *
  * @example
@@ -422,22 +106,18 @@ export { batch }
 export declare interface BlockedEvent {
     /** Why the event was blocked. */
     reason: BlockedEventReason;
-    /** Product that blocked the event. */
-    product: BlockedEventProduct;
     /** Method name that was blocked. */
     method: string;
     /** Original arguments passed to the blocked method call. */
     args: readonly unknown[];
 }
 
-declare const blockedEvent: Signal<BlockedEvent | undefined>;
-
 /**
- * Product that blocked the event.
+ * Most recent blocked-event metadata produced by consent/runtime guards.
  *
  * @public
  */
-export declare type BlockedEventProduct = 'analytics' | 'personalization';
+declare const blockedEvent: Signal<BlockedEvent | undefined>;
 
 /**
  * Reasons why an event was blocked before being sent.
@@ -455,8 +135,20 @@ export declare type BlockedEventReason = 'consent';
  *
  * @public
  */
-declare type BlockHandler = (methodName: string, args: readonly unknown[]) => void;
+export declare type BlockHandler = (methodName: string, args: readonly unknown[]) => void;
+
+/**
+ * Whether optimization selection data is available for entry resolution.
+ *
+ * @public
+ */
+declare const canOptimize: ReadonlySignal<boolean>;
 
+/**
+ * Latest optimization changes returned by the Experience API.
+ *
+ * @public
+ */
 declare const changes: Signal<ChangeArray | undefined>;
 
 /**
@@ -466,6 +158,58 @@ declare const changes: Signal<ChangeArray | undefined>;
  */
 export declare const CHANGES_CACHE_KEY = "__ctfl_opt_changes__";
 
+export declare const ClickBuilderArgs: z.ZodMiniObject<{
+    campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>;
+    locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    location: z.ZodMiniOptional<z.ZodMiniObject<{
+        coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+            latitude: z.ZodMiniNumber<number>;
+            longitude: z.ZodMiniNumber<number>;
+        }, z.core.$strip>>;
+        city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>;
+    page: z.ZodMiniOptional<z.ZodMiniObject<{
+        path: z.ZodMiniString<string>;
+        query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+        referrer: z.ZodMiniString<string>;
+        search: z.ZodMiniString<string>;
+        title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        url: z.ZodMiniString<string>;
+    }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+    screen: z.ZodMiniOptional<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+    }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+    userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    componentId: z.ZodMiniString<string>;
+    experienceId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    variantIndex: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strip>;
+
+/**
+ * Arguments for constructing entry click events.
+ *
+ * @public
+ */
+export declare type ClickBuilderArgs = z.infer<typeof ClickBuilderArgs>;
+
+/**
+ * Current optimization/analytics consent state.
+ *
+ * @public
+ */
 declare const consent: Signal<boolean | undefined>;
 
 /**
@@ -482,7 +226,7 @@ export declare const CONSENT_KEY = "__ctfl_opt_consent__";
  * @remarks
  * Intended for internal wiring between Core classes and the consent signal/store.
  */
-declare interface ConsentController {
+export declare interface ConsentController {
     /**
      * Update the runtime consent state.
      *
@@ -499,7 +243,7 @@ declare interface ConsentController {
  * These methods are consumed by the `@guardedBy` decorator to decide whether to
  * proceed with an operation and how to report blocked calls.
  */
-declare interface ConsentGuard {
+export declare interface ConsentGuard {
     /**
      * Determine whether the named operation is permitted given current consent and
      * any allow‑list configuration.
@@ -520,22 +264,59 @@ declare interface ConsentGuard {
     onBlockedByConsent: (name: string, args: unknown[]) => void;
 }
 
+/**
+ * API configuration union for Core runtimes.
+ *
+ * @public
+ */
+export declare type CoreApiConfig = CoreStatefulApiConfig | CoreStatelessApiConfig;
+
 /**
  * Internal base that wires the API client, event builder, and logging.
  *
  * @internal
  */
-declare abstract class CoreBase implements ResolverMethods {
-    /** Product implementation for analytics. */
-    protected abstract _analytics: AnalyticsBase;
-    /** Product implementation for personalization. */
-    protected abstract _personalization: PersonalizationBase;
+declare abstract class CoreBase<TConfig extends CoreConfig = CoreConfig> {
     /** Shared Optimization API client instance. */
     readonly api: ApiClient;
     /** Shared event builder instance. */
     readonly eventBuilder: EventBuilder;
-    /** Resolved core configuration (minus any name metadata). */
-    readonly config: Omit<CoreConfig, 'name'>;
+    /** Resolved core configuration. */
+    readonly config: TConfig;
+    /** Static resolver for evaluating optimized custom flags. */
+    readonly flagsResolver: {
+        resolve(changes?: ChangeArray): Flags;
+    };
+    /** Static resolver for merge-tag lookups against profile data. */
+    readonly mergeTagValueResolver: {
+        normalizeSelectors(id: string): string[];
+        getValueFromProfile(id: string, profile?: Profile): string | undefined;
+        resolve(mergeTagEntry: MergeTagEntry | undefined, profile?: Profile): string | undefined;
+    };
+    /** Static resolver for optimized Contentful entries. */
+    readonly optimizedEntryResolver: {
+        getOptimizationEntry({ optimizedEntry, selectedOptimizations, }: {
+            optimizedEntry: OptimizedEntry;
+            selectedOptimizations: SelectedOptimizationArray;
+        }, skipValidation?: boolean): OptimizationEntry | undefined;
+        getSelectedOptimization({ optimizationEntry, selectedOptimizations, }: {
+            optimizationEntry: OptimizationEntry;
+            selectedOptimizations: SelectedOptimizationArray;
+        }, skipValidation?: boolean): SelectedOptimization | undefined;
+        getSelectedVariant({ optimizedEntry, optimizationEntry, selectedVariantIndex, }: {
+            optimizedEntry: OptimizedEntry;
+            optimizationEntry: OptimizationEntry;
+            selectedVariantIndex: number;
+        }, skipValidation?: boolean): EntryReplacementVariant | undefined;
+        getSelectedVariantEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>({ optimizationEntry, selectedVariant, }: {
+            optimizationEntry: OptimizationEntry;
+            selectedVariant: EntryReplacementVariant;
+        }, skipValidation?: boolean): Entry<S, M, L> | undefined;
+        resolve: {
+            <S extends EntrySkeletonType = EntrySkeletonType, L extends LocaleCode = string>(entry: Entry<S, undefined, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, undefined, L>;
+            <S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>(entry: Entry<S, M, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, M, L>;
+        };
+    };
     /** Lifecycle interceptors for events and state updates. */
     readonly interceptors: LifecycleInterceptors;
     /**
@@ -547,26 +328,7 @@ declare abstract class CoreBase implements ResolverMethods {
      * const sdk = new CoreStateless({ clientId: 'abc123', environment: 'prod' })
      * ```
      */
-    constructor(config: CoreConfig);
-    /**
-     * Static {@link FlagsResolver | resolver} for evaluating personalized
-     * custom flags.
-     */
-    get flagsResolver(): typeof FlagsResolver;
-    /**
-     * Static {@link MergeTagValueResolver | resolver} that returns values
-     * sourced from a user profile based on a Contentful Merge Tag entry.
-     */
-    get mergeTagValueResolver(): typeof MergeTagValueResolver;
-    /**
-     * Static {@link PersonalizedEntryResolver | resolver } for personalized
-     * Contentful entries (e.g., entry variants targeted to a profile audience).
-     *
-     * @remarks
-     * Used by higher-level personalization flows to materialize entry content
-     * prior to event emission.
-     */
-    get personalizedEntryResolver(): typeof PersonalizedEntryResolver;
+    constructor(config: TConfig, api?: CoreBaseApiClientConfig);
     /**
      * Get the value of a custom flag derived from a set of optimization changes.
      *
@@ -574,174 +336,66 @@ declare abstract class CoreBase implements ResolverMethods {
      * @param changes - Optional change list to resolve from.
      * @returns The resolved JSON value for the flag if available.
      * @remarks
-     * This is a convenience wrapper around personalization’s flag resolution.
-     * @example
-     * ```ts
-     * const darkMode = core.getCustomFlag('dark-mode', data.changes)
-     * ```
-     */
-    getCustomFlag(name: string, changes?: ChangeArray): Json;
-    /**
-     * Get all resolved custom flags derived from a set of optimization changes.
-     *
-     * @param changes - Optional change list to resolve from.
-     * @returns The resolved custom flag map.
-     * @remarks
-     * This is a convenience wrapper around personalization’s flag resolution.
+     * This is a convenience wrapper around Core's shared flag resolution.
      * @example
      * ```ts
-     * const flags = core.getCustomFlags(data.changes)
+     * const darkMode = core.getFlag('dark-mode', data.changes)
      * ```
      */
-    getCustomFlags(changes?: ChangeArray): Flags;
+    getFlag(name: string, changes?: ChangeArray): Json;
     /**
-     * Resolve a Contentful entry to the appropriate personalized variant (or
+     * Resolve a Contentful entry to the appropriate optimized variant (or
      * return the baseline entry if no matching variant is selected).
      *
      * @typeParam S - Entry skeleton type.
      * @typeParam M - Chain modifiers.
      * @typeParam L - Locale code.
      * @param entry - The baseline entry to resolve.
-     * @param personalizations - Optional selection array for the current profile.
+     * @param selectedOptimizations - Optional selected optimization array for the current profile.
      * @returns {@link ResolvedData} containing the resolved entry and
-         *   personalization metadata (if any).
+         *   selected optimization metadata (if any).
+         * @remarks
+         * This helper is intended for request-local resolution. When the supplied
+         * entry comes from a shared application cache, avoid mutating the returned
+         * entry in place unless you first clone it.
          * @example
          * ```ts
-         * const { entry, personalization } = core.personalizeEntry(baselineEntry, data.personalizations)
+         * const { entry, selectedOptimization } = core.resolveOptimizedEntry(
+         *   baselineEntry,
+         *   data.selectedOptimizations,
+         * )
          * ```
          */
-     personalizeEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode>(entry: Entry<S, M, L>, personalizations?: SelectedPersonalizationArray): ResolvedData<S, M, L>;
+     resolveOptimizedEntry<S extends EntrySkeletonType = EntrySkeletonType, L extends LocaleCode = LocaleCode>(entry: Entry<S, undefined, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, undefined, L>;
+     resolveOptimizedEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode>(entry: Entry<S, M, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, M, L>;
      /**
       * Resolve a merge-tag value from the given entry node and profile.
       *
       * @param embeddedEntryNodeTarget - The merge-tag entry node to resolve.
       * @param profile - Optional profile used for value lookup.
       * @returns The resolved value (typically a string) or `undefined` if not found.
+      * @remarks
+      * Use this during request rendering with the current profile. The resolved
+      * value is profile-dependent and is not safe for shared-output caching.
       * @example
       * ```ts
       * const name = core.getMergeTagValue(mergeTagNode, profile)
       * ```
       */
      getMergeTagValue(embeddedEntryNodeTarget: MergeTagEntry, profile?: Profile): string | undefined;
-     /**
-      * Convenience wrapper for sending an `identify` event via personalization.
-      *
-      * @param payload - Identify builder arguments.
-      * @returns The resulting {@link OptimizationData} for the identified user.
-      * @example
-      * ```ts
-      * const data = await core.identify({ userId: 'user-123', traits: { plan: 'pro' } })
-      * ```
-      */
-     identify(payload: IdentifyBuilderArgs & {
-         profile?: PartialProfile;
-     }): Promise<OptimizationData | undefined>;
-     /**
-      * Convenience wrapper for sending a `page` event via personalization.
-      *
-      * @param payload - Page view builder arguments.
-      * @returns The evaluated {@link OptimizationData} for this page view.
-      * @example
-      * ```ts
-      * const data = await core.page({ properties: { title: 'Home' } })
-      * ```
-      */
-     page(payload: PageViewBuilderArgs & {
-         profile?: PartialProfile;
-     }): Promise<OptimizationData | undefined>;
-     /**
-      * Convenience wrapper for sending a `screen` event via personalization.
-      *
-      * @param payload - Screen view builder arguments.
-      * @returns The evaluated {@link OptimizationData} for this screen view.
-      * @example
-      * ```ts
-      * const data = await core.screen({ name: 'HomeScreen' })
-      * ```
-      */
-     screen(payload: ScreenViewBuilderArgs & {
-         profile?: PartialProfile;
-     }): Promise<OptimizationData | undefined>;
-     /**
-      * Convenience wrapper for sending a custom `track` event via personalization.
-      *
-      * @param payload - Track builder arguments.
-      * @returns The evaluated {@link OptimizationData} for this event.
-      * @example
-      * ```ts
-      * const data = await core.track({ event: 'button_click', properties: { label: 'Buy' } })
-      * ```
-      */
-     track(payload: TrackBuilderArgs & {
-         profile?: PartialProfile;
-     }): Promise<OptimizationData | undefined>;
-     /**
-      * Track a component view in both personalization and analytics.
-      *
-      * @param payload - Component view builder arguments. When `payload.sticky` is
-      *   `true`, the event will also be sent via personalization as a sticky
-      *   component view.
-      * @returns A promise that resolves when all delegated calls complete.
-      * @remarks
-      * The sticky behavior is delegated to personalization; analytics is always
-      * invoked regardless of `sticky`.
-      * @example
-      * ```ts
-      * await core.trackComponentView({ componentId: 'hero-banner', sticky: true })
-      * ```
-      */
-     trackComponentView(payload: ComponentViewBuilderArgs & {
-         profile?: PartialProfile;
-     }): Promise<OptimizationData | undefined>;
-     /**
-      * Track a component click via analytics.
-      *
-      * @param payload - Component click builder arguments.
-      * @returns A promise that resolves when processing completes.
-      * @example
-      * ```ts
-      * await core.trackComponentClick({ componentId: 'hero-banner' })
-      * ```
-      */
-     trackComponentClick(payload: ComponentClickBuilderArgs): Promise<void>;
-     /**
-      * Track a component hover via analytics.
-      *
-      * @param payload - Component hover builder arguments.
-      * @returns A promise that resolves when processing completes.
-      * @example
-      * ```ts
-      * await core.trackComponentHover({ componentId: 'hero-banner' })
-      * ```
-      */
-     trackComponentHover(payload: ComponentHoverBuilderArgs): Promise<void>;
-     /**
-      * Track a feature flag view via analytics.
-      *
-      * @param payload - Component view builder arguments used to build the flag view event.
-      * @returns A promise that resolves when processing completes.
-      * @example
-      * ```ts
-      * await core.trackFlagView({ componentId: 'feature-flag-123' })
-      * ```
-      */
-     trackFlagView(payload: ComponentViewBuilderArgs): Promise<void>;
+    }
+
+    declare interface CoreBaseApiClientConfig {
+        experience?: ApiClientConfig['experience'];
+        insights?: ApiClientConfig['insights'];
     }
 
     /**
-     * Options for configuring the {@link CoreBase} runtime and underlying clients.
+     * Options for configuring the `CoreBase` runtime and underlying clients.
      *
      * @public
      */
     export declare interface CoreConfig extends Pick<ApiClientConfig, GlobalApiConfigProperties> {
-        /**
-         * Configuration for the personalization (Experience) API client.
-         */
-        personalization?: Omit<ExperienceApiClientConfig, GlobalApiConfigProperties>;
-        /**
-         * Configuration for the analytics (Insights) API client.
-         */
-        analytics?: Omit<InsightsApiClientConfig, GlobalApiConfigProperties>;
         /**
          * Event builder configuration (channel/library metadata, etc.).
          */
@@ -751,225 +405,271 @@ declare abstract class CoreBase implements ResolverMethods {
     }
 
     /**
-     * Default values used to preconfigure the stateful core and products.
+     * Default values used to preconfigure the stateful core.
      *
      * @public
      */
     export declare interface CoreConfigDefaults {
         /** Global consent default applied at construction time. */
         consent?: boolean;
-        /** Default active profile used for personalization and analytics. */
+        /** Default active profile used for optimization and insights. */
         profile?: Profile;
         /** Initial diff of changes produced by the service. */
         changes?: ChangeArray;
-        /** Preselected personalization variants (e.g., winning treatments). */
-        personalizations?: SelectedPersonalizationArray;
+        /** Preselected optimization variants (e.g., winning treatments). */
+        selectedOptimizations?: SelectedOptimizationArray;
     }
 
     /**
-     * Core runtime that constructs stateful product instances and exposes shared
-     * states, including consent, blocked events, and the event stream.
+     * Shared API configuration for all Core runtimes.
+     *
+     * @public
+     */
+    export declare interface CoreSharedApiConfig {
+        /** Base URL override for Experience API requests. */
+        experienceBaseUrl?: ExperienceApiClientConfig['baseUrl'];
+        /** Base URL override for Insights API requests. */
+        insightsBaseUrl?: InsightsApiClientConfig['baseUrl'];
+        /** Experience API features enabled for outgoing requests. */
+        enabledFeatures?: ExperienceApiClientConfig['enabledFeatures'];
+    }
+
+    /**
+     * Core runtime that owns stateful event delivery, consent, and shared signals.
      *
-     * @remarks
-     * Extends {@link CoreBase} with stateful capabilities, including
-     * consent management via {@link ConsentController}.
-     * @see {@link CoreBase}
-     * @see {@link ConsentController}
      * @public
      */
-    export declare class CoreStateful extends CoreBase implements ConsentController {
+    export declare class CoreStateful extends CoreStatefulEventEmitter implements ConsentController, ConsentGuard {
         private readonly singletonOwner;
         private destroyed;
-        /** Stateful analytics product. */
-        protected _analytics: AnalyticsStateful;
-        /** Stateful personalization product. */
-        protected _personalization: PersonalizationStateful;
+        protected readonly allowedEventTypes: EventType[];
+        protected readonly experienceQueue: ExperienceQueue;
+        protected readonly insightsQueue: InsightsQueue;
+        protected readonly onEventBlocked?: CoreStatefulConfig['onEventBlocked'];
         /**
-         * Create a stateful core with optional default consent and product defaults.
-         *
-         * @param config - Core and defaults configuration.
-         * @example
-         * ```ts
-         * const core = new CoreStateful({
-         *   clientId: 'app',
-         *   environment: 'prod',
-         *   defaults: { consent: true }
-         * })
-         * core.consent(true)
-         * ```
+         * Expose merged observable state for consumers.
          */
+        readonly states: CoreStates;
         constructor(config: CoreStatefulConfig);
+        private initializeEffects;
+        private flushQueues;
+        destroy(): void;
+        reset(): void;
+        flush(): Promise<void>;
+        consent(accept: boolean): void;
+        protected get online(): boolean;
+        protected set online(isOnline: boolean);
+        registerPreviewPanel(previewPanel: PreviewPanelSignalObject): void;
+    }
+
+    /**
+     * API configuration for stateful Core runtimes.
+     *
+     * @public
+     */
+    export declare interface CoreStatefulApiConfig extends CoreSharedApiConfig {
+        /** Beacon-like handler used by Insights event delivery when available. */
+        beaconHandler?: InsightsApiClientConfig['beaconHandler'];
+        /** Experience API IP override. */
+        ip?: ExperienceApiClientConfig['ip'];
+        /** Experience API locale override. */
+        locale?: ExperienceApiClientConfig['locale'];
+        /** Experience API plain-text request toggle. */
+        plainText?: ExperienceApiClientConfig['plainText'];
+        /** Experience API preflight request toggle. */
+        preflight?: ExperienceApiClientConfig['preflight'];
+    }
+
+    /**
+     * Configuration for {@link CoreStateful}.
+     *
+     * @public
+     */
+    export declare interface CoreStatefulConfig extends CoreConfig {
         /**
-         * Release singleton ownership for stateful runtime usage.
-         *
-         * @remarks
-         * This method is idempotent and should be called when a stateful SDK instance
-         * is no longer needed (e.g. tests, hot reload, explicit teardown).
+         * Unified API configuration for stateful environments.
          */
-        destroy(): void;
+        api?: CoreStatefulApiConfig;
         /**
-         * Expose merged observable state for consumers.
-         *
-         * @returns The combined {@link CoreStates} observable object.
+         * Allow-listed event type strings permitted when consent is not set.
+         */
+        allowedEventTypes?: EventType[];
+        /** Optional set of default values applied on initialization. */
+        defaults?: CoreConfigDefaults;
+        /** Function used to obtain an anonymous user identifier. */
+        getAnonymousId?: () => string | undefined;
+        /**
+         * Callback invoked whenever an event call is blocked by checks.
          */
-        get states(): CoreStates;
+        onEventBlocked?: (event: BlockedEvent) => void;
+        /** Unified queue policy for queued stateful work. */
+        queuePolicy?: QueuePolicy;
+    }
+
+    /**
+     * Shared stateful event-emission surface extracted to keep `CoreStateful.ts`
+     * below the local max-lines limit while preserving the public API.
+     *
+     * @internal
+     */
+    declare abstract class CoreStatefulEventEmitter extends CoreBase<CoreStatefulConfig> implements ConsentGuard {
+        protected readonly flagObservables: Map<string, Observable<unknown>>;
+        protected abstract readonly allowedEventTypes: EventType[];
+        protected abstract readonly experienceQueue: ExperienceQueue;
+        protected abstract readonly insightsQueue: InsightsQueue;
+        protected abstract readonly onEventBlocked?: CoreStatefulConfig['onEventBlocked'];
+        getFlag(name: string, changes?: ChangeArray | undefined): Json;
+        resolveOptimizedEntry<S extends EntrySkeletonType = EntrySkeletonType, L extends LocaleCode = LocaleCode>(entry: Entry<S, undefined, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, undefined, L>;
+        resolveOptimizedEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode>(entry: Entry<S, M, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, M, L>;
+        getMergeTagValue(embeddedEntryNodeTarget: MergeTagEntry, profile?: Profile | undefined): string | undefined;
         /**
-         * Reset internal state. Consent and preview panel state are intentionally preserved.
+         * Convenience wrapper for sending an `identify` event through the Experience path.
          *
-         * @remarks
-         * Resetting personalization also resets analytics dependencies as a
-         * consequence of the current shared-state design.
+         * @param payload - Identify builder arguments.
+         * @returns The resulting {@link OptimizationData} for the identified user.
          * @example
          * ```ts
-         * core.reset()
+         * const data = await core.identify({ userId: 'user-123', traits: { plan: 'pro' } })
          * ```
          */
-        reset(): void;
+        identify(payload: IdentifyBuilderArgs & {
+            profile?: PartialProfile;
+        }): Promise<OptimizationData | undefined>;
         /**
-         * Flush the queues for both the analytics and personalization products.
-         * @remarks
-         * The personalization queue is only populated if events have been triggered
-         * while a device is offline.
+         * Convenience wrapper for sending a `page` event through the Experience path.
+         *
+         * @param payload - Page view builder arguments.
+         * @returns The evaluated {@link OptimizationData} for this page view.
          * @example
          * ```ts
-         * await core.flush()
+         * const data = await core.page({ properties: { title: 'Home' } })
          * ```
          */
-        flush(): Promise<void>;
+        page(payload?: PageViewBuilderArgs & {
+            profile?: PartialProfile;
+        }): Promise<OptimizationData | undefined>;
         /**
-         * Update consent state
+         * Convenience wrapper for sending a `screen` event through the Experience path.
          *
-         * @param accept - `true` if the user has granted consent; `false` otherwise.
+         * @param payload - Screen view builder arguments.
+         * @returns The evaluated {@link OptimizationData} for this screen view.
          * @example
          * ```ts
-         * core.consent(true)
+         * const data = await core.screen({ name: 'HomeScreen' })
          * ```
          */
-        consent(accept: boolean): void;
+        screen(payload: ScreenViewBuilderArgs & {
+            profile?: PartialProfile;
+        }): Promise<OptimizationData | undefined>;
         /**
-         * Read current online state.
+         * Convenience wrapper for sending a custom `track` event through the Experience path.
          *
+         * @param payload - Track builder arguments.
+         * @returns The evaluated {@link OptimizationData} for this event.
          * @example
          * ```ts
-         * if (this.online) {
-         *   await this.flush()
-         * }
+         * const data = await core.track({ event: 'button_click', properties: { label: 'Buy' } })
          * ```
          */
-        protected get online(): boolean;
+        track(payload: TrackBuilderArgs & {
+            profile?: PartialProfile;
+        }): Promise<OptimizationData | undefined>;
         /**
-         * Update online state.
+         * Track an entry view through Insights and, when sticky, Experience.
          *
-         * @param isOnline - `true` if the runtime is online; `false` otherwise.
+         * @param payload - Entry view builder arguments. When `payload.sticky` is
+         *   `true`, the event will also be sent through Experience as a sticky
+         *   entry view.
+         * @returns A promise that resolves when all delegated calls complete.
+         * @remarks
+         * Experience receives sticky entry views only; Insights is always invoked
+         * regardless of `sticky`.
          * @example
          * ```ts
-         * this.online = navigator.onLine
+         * await core.trackView({ componentId: 'entry-123', sticky: true })
          * ```
          */
-        protected set online(isOnline: boolean);
+        trackView(payload: ViewBuilderArgs & {
+            profile?: PartialProfile;
+        }): Promise<OptimizationData | undefined>;
         /**
-         * Register a preview panel compatible object to receive direct signal access.
-         * This enables the preview panel to modify SDK state for testing and simulation.
+         * Track an entry click through Insights.
          *
-         * @param previewPanel - An object implementing PreviewPanelSignalObject
-         * @remarks
-         * This method is intended for use by the Preview Panel component.
-         * Direct signal access allows immediate state updates without API calls.
+         * @param payload - Entry click builder arguments.
+         * @returns A promise that resolves when processing completes.
          * @example
          * ```ts
-         * const previewBridge: PreviewPanelSignalObject = {}
-         * core.registerPreviewPanel(previewBridge)
+         * await core.trackClick({ componentId: 'entry-123' })
          * ```
          */
-        registerPreviewPanel(previewPanel: PreviewPanelSignalObject): void;
-    }
-
-    /**
-     * Stateful analytics configuration.
-     *
-     * @public
-     */
-    export declare type CoreStatefulAnalyticsConfig = NonNullable<CoreConfig['analytics']> & {
+        trackClick(payload: ClickBuilderArgs): Promise<void>;
         /**
-         * Queue policy for stateful analytics event buffering and flush retries.
+         * Track an entry hover through Insights.
          *
-         * @see {@link AnalyticsProductConfig.queuePolicy}
-         */
-        queuePolicy?: AnalyticsProductConfig['queuePolicy'];
-    };
-
-    /**
-     * Configuration for {@link CoreStateful}.
-     *
-     * @public
-     * @see {@link CoreConfig}
-     */
-    export declare interface CoreStatefulConfig extends CoreConfig {
-        /**
-         * Configuration for the analytics (Insights) API client plus stateful queue behavior.
-         */
-        analytics?: CoreStatefulAnalyticsConfig;
-        /**
-         * Configuration for the personalization (Experience) API client plus stateful queue behavior.
+         * @param payload - Entry hover builder arguments.
+         * @returns A promise that resolves when processing completes.
+         * @example
+         * ```ts
+         * await core.trackHover({ componentId: 'entry-123' })
+         * ```
          */
-        personalization?: CoreStatefulPersonalizationConfig;
+        trackHover(payload: HoverBuilderArgs): Promise<void>;
         /**
-         * Allow-listed event type strings permitted when consent is not set.
+         * Track a feature flag view through Insights.
          *
-         * @see {@link ProductConfig.allowedEventTypes}
-         */
-        allowedEventTypes?: ProductConfig['allowedEventTypes'];
-        /** Optional set of default values applied on initialization. */
-        defaults?: CoreConfigDefaults;
-        /** Function used to obtain an anonymous user identifier. */
-        getAnonymousId?: PersonalizationProductConfig['getAnonymousId'];
-        /**
-         * Callback invoked whenever an event call is blocked by checks.
+         * @param payload - Flag view builder arguments used to build the flag view event.
+         * @returns A promise that resolves when processing completes.
+         * @example
+         * ```ts
+         * await core.trackFlagView({ componentId: 'feature-flag-123' })
+         * ```
          */
-        onEventBlocked?: ProductConfig['onEventBlocked'];
+        trackFlagView(payload: FlagViewBuilderArgs): Promise<void>;
+        hasConsent(name: string): boolean;
+        onBlockedByConsent(name: string, args: readonly unknown[]): void;
+        protected sendExperienceEvent(method: string, args: readonly unknown[], event: ExperienceEvent, _profile?: PartialProfile): Promise<OptimizationData | undefined>;
+        protected sendInsightsEvent(method: string, args: readonly unknown[], event: InsightsEvent, _profile?: PartialProfile): Promise<void>;
+        private buildFlagViewBuilderArgs;
+        protected getFlagObservable(name: string): Observable<Json>;
+        private reportBlockedEvent;
     }
 
     /**
-     * Stateful personalization configuration.
+     * Core runtime for stateless environments.
      *
      * @public
+     * Built on top of `CoreBase`. Event-emitting methods are exposed directly on
+     * the stateless instance and accept request-scoped Experience options as a
+     * separate final argument.
+     * @remarks
+     * The runtime itself is stateless, but event methods still perform outbound
+     * Experience and Insights API calls. Cache Contentful delivery data in the
+     * host application, not the results of those calls.
      */
-    export declare type CoreStatefulPersonalizationConfig = NonNullable<CoreConfig['personalization']> & {
-        /**
-         * Queue policy for stateful personalization offline event buffering.
-         *
-         * @see {@link PersonalizationProductConfig.queuePolicy}
-         */
-        queuePolicy?: PersonalizationProductConfig['queuePolicy'];
-    };
+    export declare class CoreStateless extends CoreBase<CoreStatelessConfig> {
+        constructor(config: CoreStatelessConfig);
+        identify(payload: StatelessExperiencePayload<IdentifyBuilderArgs>, requestOptions?: CoreStatelessRequestOptions): Promise<OptimizationData>;
+        page(payload?: StatelessExperiencePayload<PageViewBuilderArgs>, requestOptions?: CoreStatelessRequestOptions): Promise<OptimizationData>;
+        screen(payload: StatelessExperiencePayload<ScreenViewBuilderArgs>, requestOptions?: CoreStatelessRequestOptions): Promise<OptimizationData>;
+        track(payload: StatelessExperiencePayload<TrackBuilderArgs>, requestOptions?: CoreStatelessRequestOptions): Promise<OptimizationData>;
+        trackView(payload: StatelessStickyTrackViewPayload | StatelessNonStickyTrackViewPayload, requestOptions?: CoreStatelessRequestOptions): Promise<OptimizationData | undefined>;
+        trackClick(payload: StatelessInsightsPayload<ClickBuilderArgs>, _requestOptions?: CoreStatelessRequestOptions): Promise<void>;
+        trackHover(payload: StatelessInsightsPayload<HoverBuilderArgs>, _requestOptions?: CoreStatelessRequestOptions): Promise<void>;
+        trackFlagView(payload: StatelessInsightsPayload<FlagViewBuilderArgs>, _requestOptions?: CoreStatelessRequestOptions): Promise<void>;
+        private sendExperienceEvent;
+        private sendInsightsEvent;
+    }
 
     /**
-     * Core runtime that constructs product instances for stateless environments.
+     * API configuration for stateless Core runtimes.
      *
      * @public
-     * @see {@link CoreBase}
      */
-    export declare class CoreStateless extends CoreBase {
-        /** Stateless analytics product. */
-        protected _analytics: AnalyticsStateless;
-        /** Stateless personalization product. */
-        protected _personalization: PersonalizationStateless;
-        /**
-         * Create a stateless core. Product instances share the same API client and
-         * event builder configured in {@link CoreBase}.
-         *
-         * @param config - Stateless Core configuration.
-         * @example
-         * ```ts
-         * const sdk = new CoreStateless({ clientId: 'app', environment: 'prod' })
-         * core.trackFlagView({ componentId: 'hero' })
-         * ```
-         */
-        constructor(config: CoreStatelessConfig);
+    export declare interface CoreStatelessApiConfig extends CoreSharedApiConfig {
     }
 
     /**
-     * Configuration for the Node-specific Optimization SDK.
+     * Configuration for stateless Optimization Core runtimes.
      *
      * @public
      * @remarks
@@ -979,10 +679,9 @@ declare abstract class CoreBase implements ResolverMethods {
      */
     export declare interface CoreStatelessConfig extends CoreConfig {
         /**
-         * Override configuration for the analytics (Insights) API client. Omits
-         * `beaconHandler`.
+         * Unified API configuration for stateless environments.
          */
-        analytics?: Omit<CoreConfig['analytics'], 'beaconHandler'>;
+        api?: CoreStatelessApiConfig;
         /**
          * Overrides for the event builder configuration. Omits methods that are only
          * useful in stateful environments.
@@ -990,14 +689,20 @@ declare abstract class CoreBase implements ResolverMethods {
         eventBuilder?: Omit<EventBuilderConfig, 'getLocale' | 'getPageProperties' | 'getUserAgent'>;
     }
 
+    /**
+     * Request-bound Experience API options for stateless runtimes.
+     *
+     * @public
+     */
+    export declare interface CoreStatelessRequestOptions extends Pick<ExperienceApiClientRequestOptions, 'ip' | 'locale' | 'plainText' | 'preflight'> {
+    }
+
     /**
      * Combined observable state exposed by the stateful core.
      *
      * @public
-     * @see {@link AnalyticsStates}
-     * @see {@link PersonalizationStates}
      */
-    export declare interface CoreStates extends AnalyticsStates, PersonalizationStates {
+    export declare interface CoreStates {
         /** Current consent value (if any). */
         consent: Observable<boolean | undefined>;
         /** Whether the preview panel has been attached to the host runtime. */
@@ -1006,8 +711,16 @@ declare abstract class CoreBase implements ResolverMethods {
         previewPanelOpen: Observable<boolean>;
         /** Stream of the most recent blocked event payload. */
         blockedEventStream: Observable<BlockedEvent | undefined>;
-        /** Stream of the most recent event emitted (analytics or personalization). */
+        /** Stream of the most recent event emitted. */
         eventStream: Observable<InsightsEvent | ExperienceEvent | undefined>;
+        /** Key-scoped observable for a single Custom Flag value. */
+        flag: (name: string) => Observable<Json>;
+        /** Live view of the current profile. */
+        profile: Observable<Profile | undefined>;
+        /** Live view of selected optimizations (variants). */
+        selectedOptimizations: Observable<SelectedOptimizationArray | undefined>;
+        /** Whether optimization data is currently available. */
+        canOptimize: Observable<boolean>;
     }
 
     /**
@@ -1017,522 +730,456 @@ declare abstract class CoreBase implements ResolverMethods {
      */
     export declare const DEBUG_FLAG_KEY = "__ctfl_opt_debug__";
 
-    export { effect }
-
-    declare const event_2: Signal<InsightsEvent | ExperienceEvent | undefined>;
-
     /**
-     * Union of all event {@link AnalyticsEventType | type keys} that this package may emit.
+     * Default page properties used when no explicit page information is available.
+     *
+     * @defaultValue
+     * ```ts
+     * {
+     *   path: '',
+     *   query: {},
+     *   referrer: '',
+     *   search: '',
+     *   title: '',
+     *   url: '',
+     * }
+     * ```
+     *
+     * @remarks
+     * Values are required by the API; values may not be `undefined`. Empty values are valid.
      *
      * @public
      */
-    declare type EventType = InsightsEventType | ExperienceEventType;
+    export declare const DEFAULT_PAGE_PROPERTIES: {
+        path: string;
+        query: {};
+        referrer: string;
+        search: string;
+        title: string;
+        url: string;
+    };
 
-    declare const flags: ReadonlySignal<Flags | undefined>;
+    export { effect }
 
-    /**
-     * Resolves a {@link Flags} map from a list of optimization changes.
+    export declare const EntryInteractionBuilderArgsBase: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        componentId: z.ZodMiniString<string>;
+        experienceId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        variantIndex: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments shared by entry view, click, and hover events.
      *
      * @public
-     * @remarks
-     * Given an Optimization {@link ChangeArray}, this utility flattens the list into a
-     * simple key–value object suitable for quick lookups in client code. When `changes`
-     * is `undefined`, an empty object is returned. If a change value is wrapped in an
-     * object like `{ value: { ... } }`, this resolver unwraps it to the underlying object.
      */
-    export declare const FlagsResolver: {
-        /**
-         * Build a flattened map of flag keys to values from a change list.
-         *
-         * @param changes - The change list returned by the optimization service.
-         * @returns A map of flag keys to their resolved values.
-         * @example
-         * ```ts
-         * const flags = FlagsResolver.resolve(data.changes)
-         * if (flags['theme'] === 'dark') enableDarkMode()
-         * ```
-         * @example
-         * // Handles wrapped values produced by the API
-         * ```ts
-         * const flags = FlagsResolver.resolve([
-         *   { type: 'Variable', key: 'price', value: { value: { amount: 10, currency: 'USD' } } }
-         * ])
-         * console.log(flags.price.amount) // 10
-         * ```
-         */
-        resolve(changes?: ChangeArray): Flags;
-    };
+    export declare type EntryInteractionBuilderArgsBase = z.infer<typeof EntryInteractionBuilderArgsBase>;
 
     /**
-     * Decorator factory that **guards** class methods behind a synchronous predicate.
-     *
-     * When a decorated method is invoked:
-     * - If the predicate returns a value that evaluates to **allowed** (see `invert`), the original
-     *   method is executed and its result is returned.
-     * - If the call is **blocked**, the optional `onBlocked` hook is invoked (if configured) and:
-     *   - `undefined` is returned for sync methods; or
-     *   - `Promise<undefined>` is returned for async methods (to preserve `await` compatibility).
-     *
-     * @typeParam T - The instance type that owns both the predicate and the decorated method.
-     *
-     * @param predicateName - The name (string or symbol) of a **synchronous** instance method on `this`
-     * that acts as the predicate. It is called as `this[predicateName](methodName, argsArray)`.
-     * @param opts - Optional {@link GuardedByOptions | options} to configure inversion and `onBlocked`.
-     *
-     * @returns A methods-only class decorator compatible with Stage-3 decorators that wraps the method.
-     *
-     * @throws TypeError
-     * Thrown at initialization time (first instance construction) if `predicateName` does not resolve
-     * to a **synchronous function** on the instance.
-     *
-     * @remarks
-     * - This is a **methods-only** decorator; applying it to accessors/fields is a no-op.
-     * - The decorator preserves the original method's sync/async shape.
-     * - The predicate is invoked with `(decoratedMethodName, argsArray)` to support context-aware checks.
-     *
-     * @example
-     * Here, `canRun` allows the call when it returns truthy:
-     * ```ts
-     * class Runner {
-     *   canRun(method: string, _args: readonly unknown[]) { return method !== 'stop'; }
-     *
-     *   @guardedBy<Runner>('canRun')
-     *   go() { console.log('running'); }
-     * }
-     * ```
-     *
-     * @example
-     * Invert the predicate and call a handler on block:
-     * ```ts
-     * class Door {
-     *   isLocked() { return true } // truthy means "locked"
-     *   onBlocked(method: string) { console.warn(`${method} blocked`) }
-     *
-     *   @guardedBy<Door>('isLocked', { invert: true, onBlocked: 'onBlocked' })
-     *   open() { /* ... *\/ }
-     * }
-     * ```
+     * Most recent emitted optimization event.
      *
      * @public
      */
-    export declare function guardedBy<T extends object>(predicateName: keyof T & (string | symbol), opts?: GuardedByOptions<T>): GuardedByFunction<T>;
+    declare const event_2: Signal<InsightsEvent | ExperienceEvent | undefined>;
 
     /**
-     * The original method implementation.
-     *
-     * @typeParam A - The parameter tuple of the original method.
-     * @typeParam R - The return type of the original method.
-     * @param value - The method being decorated.
-     * @param context - The Stage-3 decorator context for a class method.
-     * @returns Nothing.
+     * Helper class for building optimization events.
      *
      * @remarks
-     * Users do not call this directly; it's returned by {@link guardedBy}.
-     *
-     * @internal
-     */
-    declare type GuardedByFunction<T extends object> = <A extends readonly unknown[], R>(value: (...args: A) => R, context: ClassMethodDecoratorContext<T, (...args: A) => R>) => void;
-
-    /**
-     * Options that tweak the behavior of {@link guardedBy}.
+     * This class coordinates configuration and argument validation to produce
+     * strongly-typed event payloads compatible with
+     * `@contentful/optimization-api-schemas`.
      *
-     * @typeParam T - The instance type on which the decorator is applied.
+     * @see {@link EventBuilderConfig}
      *
      * @public
      */
-    declare interface GuardedByOptions<T extends object> {
+    export declare class EventBuilder {
         /**
-         * Inverts the predicate result.
+         * Application metadata attached to each event.
          *
-         * When `true`, a truthy predicate result **blocks** the method.
-         * When `false` (default) or omitted, a truthy predicate result **allows** the method.
+         * @internal
+         */
+        app?: App;
+        /**
+         * Channel value attached to each event.
          *
-         * @defaultValue `false`
-         * @remarks
-         * This option is useful when the predicate expresses a *forbid* condition
-         * (e.g. "isLocked" or "isDestroyed") rather than an *allow* condition.
+         * @internal
          */
-        readonly invert?: boolean;
+        channel: Channel;
         /**
-         * Either a function to call when a method is blocked, or the name/symbol of
-         * an instance method on `this` to call when blocked.
+         * Library metadata attached to each event.
          *
-         * Both forms are **synchronous** and receive `(methodName, argsArray)`.
-         * If omitted, blocked calls fail silently (i.e., return `undefined` or
-         * `Promise<undefined>` for async methods).
+         * @internal
+         */
+        library: Library;
+        /**
+         * Function that provides the locale when available.
          *
-         * @remarks
-         * - If a property key is supplied and the instance does not have a callable at that key,
-         *   the hook is ignored.
-         * - The hook **must not** be `async`; any async work should be scheduled manually.
+         * @internal
          */
-        readonly onBlocked?: BlockHandler | (keyof T & (string | symbol));
-    }
-
-    /**
-     * A function that receives a value of type `T` and returns a (possibly async)
-     * value of the same type `T`. The input is marked as `readonly` to discourage
-     * mutation of the original object.
-     *
-     * @typeParam T - The value type intercepted and returned.
-     * @param value - The current (readonly) value in the interception chain.
-     * @returns The next value for the chain, either directly or via a promise.
-     * @remarks Implementations SHOULD avoid mutating `value` and instead return a
-     * new or safely-updated instance.
-     * @see {@link InterceptorManager}
-     * @public
-     */
-    export declare type Interceptor<T> = (value: Readonly<T>) => MaybePromise<T>;
-
-    /**
-     * Manages a list of interceptors and provides a way to run them in sequence.
-     *
-     * Interceptors are executed in insertion order. Each interceptor receives the
-     * result of the previous interceptor (or the initial input for the first one)
-     * and may return a new value synchronously or asynchronously.
-     *
-     * @typeParam T - The value type processed by the interceptors.
-     * @remarks This class snapshots the current interceptor list at invocation time
-     * so additions/removals during `run` do not affect the in-flight execution.
-     * @example
-     * ```ts
-     * const mgr = new InterceptorManager<number>();
-     * const id = mgr.add((n) => n + 1);
-     * const final = await mgr.run(1); // 2
-     * mgr.remove(id);
-     * ```
-     * @public
-     */
-    export declare class InterceptorManager<T> {
+        getLocale: () => string | undefined;
         /**
-         * The registry of interceptors keyed by their insertion id.
+         * Function that provides baseline page properties.
          *
-         * @privateRemarks Internal storage; use {@link add}, {@link remove}, and
-         * {@link clear} to manage contents.
-         * @readonly
-         * @defaultValue `new Map()`
+         * @internal
          */
-        private readonly interceptors;
+        getPageProperties: () => Page;
         /**
-         * The next numeric id to assign to an added interceptor.
+         * Function that provides the user agent string when available.
          *
-         * @privateRemarks Used only to generate unique, monotonically increasing ids.
-         * @defaultValue `0`
+         * @internal
          */
-        private nextId;
+        getUserAgent: () => string | undefined;
         /**
-         * Add an interceptor and return its identifier.
+         * Creates a new {@link EventBuilder} instance.
+         *
+         * @param config - Configuration used to customize event payloads.
+         *
+         * @remarks
+         * Callers are expected to reuse a single instance when possible to avoid
+         * repeatedly reconfiguring the builder.
          *
-         * @param interceptor - The interceptor function to register.
-         * @returns The numeric id that can later be used with {@link remove}.
-         * @remarks Interceptors are executed in the order they are added.
          * @example
          * ```ts
-         * const id = manager.add(async (value) => transform(value));
+         * const builder = new EventBuilder({
+         *   channel: 'web',
+         *   library: { name: '@contentful/optimization-sdk', version: '1.0.0' },
+         * })
          * ```
-         * @public
          */
-        add(interceptor: Interceptor<T>): number;
+        constructor(config: EventBuilderConfig);
         /**
-         * Remove an interceptor by its identifier.
+         * Builds the universal event properties shared across all event types.
+         *
+         * @param args - Arguments overriding the default context values.
+         * @returns A fully populated {@link UniversalEventProperties} object.
+         *
+         * @remarks
+         * This method is used internally by the specific event-builder methods
+         * (e.g. {@link EventBuilder.buildPageView}).
+         */
+        protected buildUniversalEventProperties({ campaign, locale, location, page, screen, userAgent, }: UniversalEventBuilderArgs): UniversalEventProperties;
+        private buildEntryInteractionBase;
+        /**
+         * Builds a `component` view event payload for entry exposure tracking.
+         *
+         * @param args - {@link ViewBuilderArgs} arguments describing the entry view.
+         * @returns A {@link ViewEvent} describing the view.
          *
-         * @param id - The id previously returned by {@link add}.
-         * @returns `true` if an interceptor was removed; otherwise `false`.
          * @example
          * ```ts
-         * const removed = manager.remove(id);
+         * const event = builder.buildView({
+         *   componentId: 'entry-123',
+         *   viewId: crypto.randomUUID(),
+         *   experienceId: 'experience-123',
+         *   variantIndex: 1,
+         *   viewDurationMs: 1_000,
+         * })
          * ```
+         *
          * @public
          */
-        remove(id: number): boolean;
+        buildView(args: ViewBuilderArgs): ViewEvent;
         /**
-         * Remove all registered interceptors.
+         * Builds a `component_click` payload for entry click tracking.
+         *
+         * @param args - {@link ClickBuilderArgs} arguments describing the entry click.
+         * @returns A {@link ClickEvent} describing the click.
          *
-         * @returns Nothing.
-         * @remarks After calling this, {@link count} will return `0`.
          * @example
          * ```ts
-         * manager.clear();
+         * const event = builder.buildClick({
+         *   componentId: 'entry-123',
+         *   experienceId: 'experience-123',
+         *   variantIndex: 1,
+         * })
          * ```
+         *
          * @public
          */
-        clear(): void;
+        buildClick(args: ClickBuilderArgs): ClickEvent;
         /**
-         * Get the number of currently registered interceptors.
+         * Builds a `component_hover` payload for entry hover tracking.
+         *
+         * @param args - {@link HoverBuilderArgs} arguments describing the entry hover.
+         * @returns A {@link HoverEvent} describing the hover.
          *
-         * @returns The count of interceptors.
          * @example
          * ```ts
-         * if (manager.count() === 0) { /* ... *\/ }
+         * const event = builder.buildHover({
+         *   componentId: 'entry-123',
+         *   hoverId: crypto.randomUUID(),
+         *   experienceId: 'experience-123',
+         *   hoverDurationMs: 1_000,
+         *   variantIndex: 1,
+         * })
          * ```
+         *
          * @public
          */
-        count(): number;
+        buildHover(args: HoverBuilderArgs): HoverEvent;
         /**
-         * Run all interceptors in sequence on an input value and return the final result.
+         * Builds a `component` view event payload for Custom Flag exposure tracking.
          *
-         * Supports both sync and async interceptors; the return type is always `Promise<T>`
-         * for consistency.
+         * @param args - {@link FlagViewBuilderArgs} arguments describing the Custom Flag view.
+         * @returns A {@link ViewEvent} describing the view.
+         *
+         * @remarks
+         * This is a specialized variant of {@link EventBuilder.buildView}
+         * that sets `componentType` to `'Variable'`.
          *
-         * @param input - The initial value to pass to the first interceptor.
-         * @returns A promise resolving to the final value after all interceptors have run.
-         * @throws May rethrow any error thrown by an interceptor. <!-- Intentionally vague: error type depends on interceptor implementation -->
-         * @remarks The interceptor list is snapshotted at invocation time; changes to
-         * the registry during execution do not affect the running sequence.
          * @example
          * ```ts
-         * const result = await manager.run(initial);
+         * const event = builder.buildFlagView({
+         *   componentId: 'feature-flag-key',
+         *   viewId: crypto.randomUUID(),
+         *   experienceId: 'experience-123',
+         *   viewDurationMs: 1_000,
+         * })
          * ```
+         *
          * @public
          */
-        run(input: T): Promise<T>;
-    }
-
-    /**
-     * Lifecycle container for event and state interceptors.
-     *
-     * @public
-     */
-    export declare interface LifecycleInterceptors {
-        /** Interceptors invoked for individual events prior to validation/sending. */
-        event: InterceptorManager<InsightsEvent | ExperienceEvent>;
-        /** Interceptors invoked before optimization state updates. */
-        state: InterceptorManager<OptimizationData>;
-    }
-
-    /**
-     * A utility type representing a value that may be synchronously available or
-     * produced asynchronously.
-     *
-     * @typeParam T - The resolved value type.
-     * @public
-     */
-    declare type MaybePromise<T> = T | Promise<T>;
-
-    /**
-     * Resolves merge tag values from a {@link Profile}.
-     *
-     * @public
-     * @remarks
-     * *Merge tags* are references to user profile data that may be embedded in content
-     * and expanded at runtime. This resolver normalizes the merge-tag identifier into
-     * a set of candidate selectors and searches the profile for a matching value.
-     * Result values are returned as strings; numeric/boolean primitives are stringified.
-     */
-    export declare const MergeTagValueResolver: {
+        buildFlagView(args: FlagViewBuilderArgs): ViewEvent;
         /**
-         * Generate a list of candidate selectors for a merge-tag ID.
+         * Builds an identify event payload to associate a user ID with traits.
+         *
+         * @param args - {@link IdentifyBuilderArgs} arguments describing the identified user.
+         * @returns An {@link IdentifyEvent} payload.
+         *
+         * @remarks
+         * - Traits are merged by the API; only specified properties may be overwritten.
+         * - The User ID is consumer-specified and should not contain the value of any
+         *   ID generated by the Experience API.
          *
-         * @param id - Merge-tag identifier (segments separated by `_`).
-         * @returns Array of dot-path selectors to try against a profile.
          * @example
          * ```ts
-         * // "profile_name_first" -> [
-         * //   'profile',
-         * //   'profile.name',
-         * //   'profile.name.first'
-         * // ]
-         * const selectors = MergeTagValueResolver.normalizeSelectors('profile_name_first')
+         * const event = builder.buildIdentify({
+         *   userId: 'user-123',
+         *   traits: { plan: 'pro' },
+         * })
          * ```
+         *
+         * @public
          */
-        normalizeSelectors(id: string): string[];
+        buildIdentify(args: IdentifyBuilderArgs): IdentifyEvent;
         /**
-         * Look up a merge-tag value from a profile using normalized selectors.
+         * Builds a page view event payload.
+         *
+         * @param args - Optional {@link PageViewBuilderArgs} overrides for the page view event.
+         * @returns A {@link PageViewEvent} payload.
          *
-         * @param id - Merge-tag identifier.
-         * @param profile - Profile from which to resolve the value.
-         * @returns A stringified primitive if found; otherwise `undefined`.
          * @remarks
-         * Only string/number/boolean primitives are returned; objects/arrays are ignored.
+         * Page properties are created by merging:
+         * 1. The base page properties from {@link EventBuilderConfig.getPageProperties}, and
+         * 2. The partial `properties` argument passed in.
+         *
+         * The title always falls back to {@link DEFAULT_PAGE_PROPERTIES}.title when undefined.
+         *
          * @example
          * ```ts
-         * const value = MergeTagValueResolver.getValueFromProfile('user_email', profile)
-         * if (value) sendEmailTo(value)
+         * const event = builder.buildPageView({
+         *   properties: {
+         *     title: 'Homepage',
+         *   },
+         * })
          * ```
+         *
+         * @public
          */
-        getValueFromProfile(id: string, profile?: Profile): string | undefined;
+        buildPageView(args?: PageViewBuilderArgs): PageViewEvent;
         /**
-         * Resolve the display value for a merge-tag entry using the provided profile,
-         * falling back to the entry's configured `nt_fallback` when necessary.
+         * Builds a screen view event payload.
+         *
+         * @param args - {@link ScreenViewBuilderArgs} arguments for the screen view event.
+         * @returns A {@link ScreenViewEvent} payload.
          *
-         * @param mergeTagEntry - The merge-tag entry to resolve.
-         * @param profile - Optional profile used for lookup.
-         * @returns The resolved string, or `undefined` if the entry is invalid and no
-         * fallback is available.
          * @example
          * ```ts
-         * const text = MergeTagValueResolver.resolve(entry, profile)
-         * render(text ?? 'Guest')
+         * const event = builder.buildScreenView({
+         *   name: 'home',
+         *   properties: {
+         *     title: 'Home Screen',
+         *   },
+         * })
          * ```
+         *
+         * @public
          */
-        resolve(mergeTagEntry: MergeTagEntry | undefined, profile?: Profile): string | undefined;
-    };
-
-    declare interface Observable<T> {
-        subscribe: (next: (v: T) => void) => Subscription;
+        buildScreenView(args: ScreenViewBuilderArgs): ScreenViewEvent;
+        /**
+         * Builds a track event payload for arbitrary user actions.
+         *
+         * @param args - {@link TrackBuilderArgs} arguments describing the tracked event.
+         * @returns A {@link TrackEvent} payload.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildTrack({
+         *   event: 'button_clicked',
+         *   properties: { id: 'primary-cta', location: 'hero' },
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildTrack(args: TrackBuilderArgs): TrackEvent_2;
     }
 
-    declare const online: Signal<boolean | undefined>;
-
     /**
-     * The package name of the Optimization Core SDK, injected at build time.
+     * Configuration options for creating an {@link EventBuilder} instance.
      *
-     * @public
-     */
-    export declare const OPTIMIZATION_CORE_SDK_NAME: string;
-
-    /**
-     * The current version of the Optimization Core SDK, injected at build time.
+     * @remarks
+     * The configuration is typically provided by the host application to adapt
+     * event payloads to the runtime environment (browser, framework, etc.).
      *
-     * @public
-     */
-    export declare const OPTIMIZATION_CORE_SDK_VERSION: string;
-
-    /**
-     * Internal base for personalization products.
+     * @example
+     * ```ts
+     * const builder = new EventBuilder({
+     *   app: { name: 'my-app', version: '1.0.0' },
+     *   channel: 'web',
+     *   library: { name: '@contentful/optimization-sdk', version: '1.2.3' },
+     *   getLocale: () => navigator.language,
+     *   getPageProperties: () => ({
+     *     path: window.location.pathname,
+     *     url: window.location.href,
+     *     title: document.title,
+     *     query: {},
+     *     referrer: document.referrer,
+     *     search: window.location.search,
+     *   }),
+     * })
+     * ```
      *
-     * @internal
-     * @remarks
-     * Concrete implementations should extend this class to expose public methods for
-     * identify, page, and track events. This base wires in shared singleton
-     * resolvers used to fetch/resolve personalized data.
+     * @public
      */
-    export declare abstract class PersonalizationBase extends ProductBase implements ResolverMethods {
-        /**
-         * Static {@link FlagsResolver | resolver} for evaluating personalized
-         * custom flags.
-         */
-        readonly flagsResolver: {
-            resolve(changes?: ChangeArray): Flags;
-        };
-        /**
-         * Static {@link MergeTagValueResolver | resolver} that returns values
-         * sourced from a user profile based on a Contentful Merge Tag entry.
-         */
-        readonly mergeTagValueResolver: {
-            normalizeSelectors(id: string): string[];
-            getValueFromProfile(id: string, profile?: Profile): string | undefined;
-            resolve(mergeTagEntry: MergeTagEntry | undefined, profile?: Profile): string | undefined;
-        };
+    export declare interface EventBuilderConfig {
         /**
-         * Static {@link PersonalizedEntryResolver | resolver } for personalized
-         * Contentful entries (e.g., entry variants targeted to a profile audience).
+         * The application definition used to attribute events to a specific consumer app.
          *
          * @remarks
-         * Used by higher-level personalization flows to materialize entry content
-         * prior to event emission.
-         */
-        readonly personalizedEntryResolver: {
-            getPersonalizationEntry({ personalizedEntry, selectedPersonalizations, }: {
-                personalizedEntry: PersonalizedEntry;
-                selectedPersonalizations: SelectedPersonalizationArray;
-            }, skipValidation?: boolean): PersonalizationEntry | undefined;
-            getSelectedPersonalization({ personalizationEntry, selectedPersonalizations, }: {
-                personalizationEntry: PersonalizationEntry;
-                selectedPersonalizations: SelectedPersonalizationArray;
-            }, skipValidation?: boolean): SelectedPersonalization_2 | undefined;
-            getSelectedVariant({ personalizedEntry, personalizationEntry, selectedVariantIndex, }: {
-                personalizedEntry: PersonalizedEntry;
-                personalizationEntry: PersonalizationEntry;
-                selectedVariantIndex: number;
-            }, skipValidation?: boolean): EntryReplacementVariant | undefined;
-            getSelectedVariantEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>({ personalizationEntry, selectedVariant, }: {
-                personalizationEntry: PersonalizationEntry;
-                selectedVariant: EntryReplacementVariant;
-            }, skipValidation?: boolean): Entry<S, M, L> | undefined;
-            resolve<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>(entry: Entry<S, M, L>, selectedPersonalizations?: SelectedPersonalizationArray): ResolvedData<S, M, L>;
-        };
-        /**
-         * Get the specified Custom Flag's value from the supplied changes.
-         * @param name - The name/key of the Custom Flag.
-         * @param changes - Optional changes array.
-         * @returns The current value of the Custom Flag if found.
-         * @remarks
-         * The changes array can be sourced from the data returned when emitting any
-         * personalization event.
-         * */
-        getCustomFlag(name: string, changes?: ChangeArray): Json;
-        /**
-         * Get all resolved Custom Flags from the supplied changes.
-         * @param changes - Optional changes array.
-         * @returns The resolved Custom Flag map.
-         * @remarks
-         * The changes array can be sourced from the data returned when emitting any
-         * personalization event.
-         * */
-        getCustomFlags(changes?: ChangeArray): Flags;
+         * When not provided, events will not contain app metadata in their context.
+         */
+        app?: App;
         /**
-         * Resolve a Contentful entry to a personalized variant using the current
-         * or provided selected personalizations.
+         * The channel that identifies where events originate from (e.g. web, mobile).
          *
-         * @typeParam S - Entry skeleton type.
-         * @typeParam M - Chain modifiers.
-         * @typeParam L - Locale code.
-         * @param entry - The entry to personalize.
-         * @param personalizations - Optional selected personalizations.
-         * @returns The resolved entry data.
-         * @remarks
-         * Selected personalizations can be sourced from the data returned when emitting any
-         * personalization event.
+         * @see {@link Channel}
          */
-        personalizeEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode>(entry: Entry<S, M, L>, personalizations?: SelectedPersonalizationArray): ResolvedData<S, M, L>;
+        channel: Channel;
         /**
-         * Resolve a merge tag to a value based on the current (or provided) profile.
+         * The client library metadata that is attached to all events.
          *
-         * @param embeddedEntryNodeTarget - The merge tag entry node to resolve.
-         * @param profile - Optional profile.
-         * @returns The resolved value (type depends on the tag).
          * @remarks
-         * Merge tags are references to profile data that can be substituted into content. The
-         * profile can be sourced from the data returned when emitting any personalization event.
+         * This is typically used to record the library name and version.
          */
-        getMergeTagValue(embeddedEntryNodeTarget: MergeTagEntry, profile?: Profile): string | undefined;
+        library: Library;
         /**
-         * Identify the current profile/visitor to associate traits with a profile.
+         * Function used to resolve the locale for outgoing events.
          *
-         * @param payload - Identify builder payload.
-         * @returns The resulting {@link OptimizationData} for the identified user if the device is online.
-         */
-        abstract identify(payload: IdentifyBuilderArgs): Promise<OptimizationData | undefined>;
-        /**
-         * Record a page view.
+         * @remarks
+         * If not provided, the builder falls back to the default `'en-US'`. Locale
+         * values supplied directly as arguments to event builder methods take
+         * precedence.
          *
-         * @param payload - Page view builder payload.
-         * @returns The evaluated {@link OptimizationData} for this page view if the device is online.
+         * @returns The locale string (e.g. `'en-US'`), or `undefined` if unavailable.
          */
-        abstract page(payload: PageViewBuilderArgs): Promise<OptimizationData | undefined>;
+        getLocale?: () => string | undefined;
         /**
-         * Record a screen view.
+         * Function that returns the current page properties.
+         *
+         * @remarks
+         * Page properties are currently added to the context of all events, as well
+         * as the `properties` of the page event. When specified, all properties of
+         * the `Page` type are required, but may contain empty values.
          *
-         * @param payload - Screen view builder payload.
-         * @returns The evaluated {@link OptimizationData} for this screen view if the device is online.
+         * @returns A {@link Page} object containing information about the current page.
+         * @see {@link Page}
          */
-        abstract screen(payload: ScreenViewBuilderArgs): Promise<OptimizationData | undefined>;
+        getPageProperties?: () => Page;
         /**
-         * Record a custom track event.
+         * Function used to obtain the current user agent string when applicable.
          *
-         * @param payload - Track builder payload.
-         * @returns The evaluated {@link OptimizationData} for this event if the device is online.
+         * @returns A user agent string, or `undefined` if unavailable.
          */
-        abstract track(payload: TrackBuilderArgs): Promise<OptimizationData | undefined>;
-        /**
-         * Record a "sticky" component view.
-         *
-         * @param payload - "Sticky" component view builder payload.
-         * @returns The evaluated {@link OptimizationData} for this component view if the device is online.
-         * @remarks
-         * This method is intended to be called only when a component is considered
-         * "sticky".
-         */
-        abstract trackComponentView(payload: ComponentViewBuilderArgs): Promise<OptimizationData | undefined>;
+        getUserAgent?: () => string | undefined;
     }
 
     /**
-     * Context payload emitted when offline personalization events are dropped due to queue bounds.
+     * Union of all event type keys that stateful Core may emit.
      *
      * @public
      */
-    export declare interface PersonalizationOfflineQueueDropContext {
+    export declare type EventType = InsightsEventType | ExperienceEventType;
+
+    /**
+     * Internal Experience send/offline runtime used by {@link CoreStateful}.
+     *
+     * @internal
+     */
+    declare class ExperienceQueue {
+        private readonly experienceApi;
+        private readonly eventInterceptors;
+        private readonly flushRuntime;
+        private readonly getAnonymousId;
+        private readonly offlineMaxEvents;
+        private readonly onOfflineDrop?;
+        private readonly queuedExperienceEvents;
+        private readonly stateInterceptors;
+        constructor(options: ExperienceQueueOptions);
+        clearScheduledRetry(): void;
+        send(event: ExperienceEvent): Promise<OptimizationData | undefined>;
+        flush(options?: {
+            force?: boolean;
+        }): Promise<void>;
+        private enqueueEvent;
+        private dropOldestEvents;
+        private invokeOfflineDropCallback;
+        private tryUpsertQueuedEvents;
+        private upsertProfile;
+        private updateOutputSignals;
+    }
+
+    /**
+     * Context payload emitted when offline Experience events are dropped.
+     *
+     * @public
+     */
+    export declare interface ExperienceQueueDropContext {
         /** Number of dropped events. */
         droppedCount: number;
         /** Dropped events in oldest-first order. */
@@ -1543,533 +1190,682 @@ declare abstract class CoreBase implements ResolverMethods {
         queuedEvents: number;
     }
 
+    declare interface ExperienceQueueOptions {
+        experienceApi: {
+            upsertProfile: (payload: {
+                profileId?: string;
+                events: ExperienceEventArray;
+            }) => Promise<OptimizationData>;
+        };
+        eventInterceptors: LifecycleInterceptors['event'];
+        flushPolicy: ResolvedQueueFlushPolicy;
+        getAnonymousId: () => string | undefined;
+        offlineMaxEvents: number;
+        onOfflineDrop?: (context: ExperienceQueueDropContext) => void;
+        stateInterceptors: LifecycleInterceptors['state'];
+    }
+
     /**
-     * Configuration for {@link PersonalizationStateful}.
+     * Resolves a {@link Flags} map from a list of optimization changes.
      *
      * @public
+     * @remarks
+     * Given an Optimization {@link ChangeArray}, this utility flattens the list into a
+     * simple key–value object suitable for quick lookups in client code. When `changes`
+     * is `undefined`, an empty object is returned. If a change value is wrapped in an
+     * object like `{ value: { ... } }`, this resolver unwraps it to the underlying object.
      */
-    export declare interface PersonalizationProductConfig extends ProductConfig {
-        /** Default signal values applied during initialization. */
-        defaults?: PersonalizationProductConfigDefaults;
-        /**
-         * Policy that controls the offline personalization queue size and drop telemetry.
-         */
-        queuePolicy?: PersonalizationQueuePolicy;
+    export declare const FlagsResolver: {
         /**
-         * Function used to obtain an anonymous user identifier.
-         *
-         * @remarks
-         * If a `getAnonymousId` function has been provided, the returned value will
-         * take precedence over the `id` property of the current {@link Profile}
-         * signal value
+         * Build a flattened map of flag keys to values from a change list.
          *
-         * @returns A string identifier, or `undefined` if no anonymous ID is available.
+         * @param changes - The change list returned by the optimization service.
+         * @returns A map of flag keys to their resolved values.
+         * @example
+         * ```ts
+         * const flags = FlagsResolver.resolve(data.changes)
+         * if (flags['theme'] === 'dark') enableDarkMode()
+         * ```
+         * @example
+         * // Handles wrapped values produced by the API
+         * ```ts
+         * const flags = FlagsResolver.resolve([
+         *   { type: 'Variable', key: 'price', value: { value: { amount: 10, currency: 'USD' } } }
+         * ])
+         * console.log(flags.price.amount) // 10
+         * ```
          */
-        getAnonymousId?: () => string | undefined;
-    }
+        resolve(changes?: ChangeArray): Flags_2;
+    };
 
-    /**
-     * Default state values for {@link PersonalizationStateful} applied at construction time.
+    export declare const FlagViewBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        componentId: z.ZodMiniString<string>;
+        experienceId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        variantIndex: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        viewId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        viewDurationMs: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing Custom Flag view events.
      *
      * @public
      */
-    export declare interface PersonalizationProductConfigDefaults {
-        /** Whether personalization is allowed by default. */
-        consent?: boolean;
-        /** Initial diff of changes produced by the service. */
-        changes?: ChangeArray;
-        /** Default active profile used for personalization. */
-        profile?: Profile;
-        /** Preselected personalization variants (e.g., winning treatments). */
-        personalizations?: SelectedPersonalizationArray;
-    }
+    export declare type FlagViewBuilderArgs = z.infer<typeof FlagViewBuilderArgs>;
 
     /**
-     * Policy options for the stateful personalization offline queue.
+     * Decorator factory that **guards** class methods behind a synchronous predicate.
+     *
+     * When a decorated method is invoked:
+     * - If the predicate returns a value that evaluates to **allowed** (see `invert`), the original
+     *   method is executed and its result is returned.
+     * - If the call is **blocked**, the optional `onBlocked` hook is invoked (if configured) and:
+     *   - `undefined` is returned for sync methods; or
+     *   - `Promise<undefined>` is returned for async methods (to preserve `await` compatibility).
+     *
+     * @typeParam T - The instance type that owns both the predicate and the decorated method.
+     *
+     * @param predicateName - The name (string or symbol) of a **synchronous** instance method on `this`
+     * that acts as the predicate. It is called as `this[predicateName](methodName, argsArray)`.
+     * @param opts - Optional `GuardedByOptions` to configure inversion and `onBlocked`.
+     *
+     * @returns A methods-only class decorator compatible with Stage-3 decorators that wraps the method.
+     *
+     * @throws TypeError
+     * Thrown at initialization time (first instance construction) if `predicateName` does not resolve
+     * to a **synchronous function** on the instance.
+     *
+     * @remarks
+     * - This is a **methods-only** decorator; applying it to accessors/fields is a no-op.
+     * - The decorator preserves the original method's sync/async shape.
+     * - The predicate is invoked with `(decoratedMethodName, argsArray)` to support context-aware checks.
+     *
+     * @example
+     * Here, `canRun` allows the call when it returns truthy:
+     * ```ts
+     * class Runner {
+     *   canRun(method: string, _args: readonly unknown[]) { return method !== 'stop'; }
+     *
+     *   @guardedBy<Runner>('canRun')
+     *   go() { console.log('running'); }
+     * }
+     * ```
+     *
+     * @example
+     * Invert the predicate and call a handler on block:
+     * ```ts
+     * class Door {
+     *   isLocked() { return true } // truthy means "locked"
+     *   onBlocked(method: string) { console.warn(`${method} blocked`) }
+     *
+     *   @guardedBy<Door>('isLocked', { invert: true, onBlocked: 'onBlocked' })
+     *   open() { /* ... *\/ }
+     * }
+     * ```
      *
      * @public
      */
-    export declare interface PersonalizationQueuePolicy {
-        /**
-         * Maximum number of personalization events retained while offline.
-         */
-        maxEvents?: number;
-        /**
-         * Callback invoked whenever oldest events are dropped due to queue bounds.
-         */
-        onDrop?: (context: PersonalizationOfflineQueueDropContext) => void;
-        /**
-         * Policy that controls offline queue flush retries, backoff, and circuit
-         * behavior after repeated failures.
-         */
-        flushPolicy?: QueueFlushPolicy;
-    }
-
-    declare const personalizations: Signal<{
-        experienceId: string;
-        variantIndex: number;
-        variants: Record<string, string>;
-        sticky?: boolean | undefined;
-    }[] | undefined>;
+    export declare function guardedBy<T extends object>(predicateName: keyof T & (string | symbol), opts?: GuardedByOptions<T>): GuardedByFunction<T>;
 
     /**
-     * Storage key for cached selected personalizations.
+     * The original method implementation.
+     *
+     * @typeParam A - The parameter tuple of the original method.
+     * @typeParam R - The return type of the original method.
+     * @param value - The method being decorated.
+     * @param context - The Stage-3 decorator context for a class method.
+     * @returns Nothing.
+     *
+     * @remarks
+     * Users do not call this directly; it's returned by {@link guardedBy}.
      *
      * @internal
      */
-    export declare const PERSONALIZATIONS_CACHE_KEY = "__ctfl_opt_personalizations__";
+    export declare type GuardedByFunction<T extends object> = <A extends readonly unknown[], R>(value: (...args: A) => R, context: ClassMethodDecoratorContext<T, (...args: A) => R>) => void;
 
     /**
-     * Stateful personalization product that manages consent, profile, flags, and
-     * selected variants while emitting Experience events and updating state.
+     * Options that tweak the behavior of {@link guardedBy}.
+     *
+     * @typeParam T - The instance type on which the decorator is applied.
      *
      * @public
-     * @remarks
-     * The class maintains reactive signals and exposes read‑only observables via
-     * {@link PersonalizationStateful.states}. Events are validated via schema parsers and
-     * run through interceptors before being submitted. Resulting state is merged
-     * back into signals.
-     */
-    export declare class PersonalizationStateful extends PersonalizationBase implements ConsentGuard {
-        /** In-memory ordered queue for offline personalization events. */
-        private readonly offlineQueue;
-        /** Resolved offline queue policy values. */
-        private readonly queuePolicy;
-        /** Shared queue flush retry runtime state machine. */
-        private readonly flushRuntime;
-        /** Exposed observable state references. */
-        readonly states: PersonalizationStates;
-        /**
-         * Function that provides an anonymous ID when available.
-         *
-         * @internal
-         */
-        getAnonymousId: () => string | undefined;
+     */
+    export declare interface GuardedByOptions<T extends object> {
         /**
-         * Create a new stateful personalization instance.
+         * Inverts the predicate result.
          *
-         * @param options - Options to configure the personalization product for stateful environments.
-         * @example
-         * ```ts
-         * const personalization = new PersonalizationStateful({ api, builder, config: { getAnonymousId }, interceptors })
-         * ```
-         */
-        constructor(options: PersonalizationStatefulOptions);
-        /**
-         * Reset stateful signals managed by this product.
+         * When `true`, a truthy predicate result **blocks** the method.
+         * When `false` (default) or omitted, a truthy predicate result **allows** the method.
          *
+         * @defaultValue `false`
          * @remarks
-         * Clears `changes`, `profile`, and selected `personalizations`.
-         * @example
-         * ```ts
-         * personalization.reset()
-         * ```
-         */
-        reset(): void;
-        /**
-         * Get the specified Custom Flag's value (derived from the signal).
-         * @param name - The name or key of the Custom Flag.
-         * @returns The current value of the Custom Flag if found.
-         * @example
-         * ```ts
-         * const flagValue = personalization.getCustomFlag('dark-mode')
-         * ```
-         * */
-        getCustomFlag(name: string, changes?: ChangeArray | undefined): Json;
-        /**
-         * Get all resolved Custom Flags (derived from the signal).
-         * @param changes - Optional changes array; defaults to the current signal value.
-         * @returns The resolved Custom Flag map.
-         * @example
-         * ```ts
-         * const flags = personalization.getCustomFlags()
-         * ```
+         * This option is useful when the predicate expresses a *forbid* condition
+         * (e.g. "isLocked" or "isDestroyed") rather than an *allow* condition.
          */
-        getCustomFlags(changes?: ChangeArray | undefined): Flags;
+        readonly invert?: boolean;
         /**
-         * Resolve a Contentful entry to a personalized variant using the current
-         * or provided selections.
+         * Either a function to call when a method is blocked, or the name/symbol of
+         * an instance method on `this` to call when blocked.
          *
-         * @typeParam S - Entry skeleton type.
-         * @typeParam M - Chain modifiers.
-         * @typeParam L - Locale code.
-         * @param entry - The entry to personalize.
-         * @param personalizations - Optional selections; defaults to the current signal value.
-         * @returns The resolved entry data.
-         * @example
-         * ```ts
-         * const { entry } = personalization.personalizeEntry(baselineEntry)
-         * ```
-         */
-        personalizeEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode>(entry: Entry<S, M, L>, personalizations?: SelectedPersonalizationArray | undefined): ResolvedData<S, M, L>;
-        /**
-         * Resolve a merge tag to a value based on the current (or provided) profile.
+         * Both forms are **synchronous** and receive `(methodName, argsArray)`.
+         * If omitted, blocked calls fail silently (i.e., return `undefined` or
+         * `Promise<undefined>` for async methods).
          *
-         * @param embeddedEntryNodeTarget - The merge‑tag entry node to resolve.
-         * @param profile - Optional profile; defaults to the current signal value.
-         * @returns The resolved value (type depends on the tag).
          * @remarks
-         * Merge tags are references to profile data that can be substituted into content.
-         * @example
-         * ```ts
-         * const name = personalization.getMergeTagValue(mergeTagNode)
-         * ```
-         */
-        getMergeTagValue(embeddedEntryNodeTarget: MergeTagEntry, profile?: Profile | undefined): string | undefined;
-        /**
-         * Determine whether the named operation is permitted based on consent and
-         * allowed event type configuration.
-         *
-         * @param name - Method name; `trackComponentView` is normalized to
-         * `'component'` for allow‑list checks.
-         * @returns `true` if the operation is permitted; otherwise `false`.
-         * @example
-         * ```ts
-         * if (personalization.hasConsent('track')) { ... }
-         * ```
+         * - If a property key is supplied and the instance does not have a callable at that key,
+         *   the hook is ignored.
+         * - The hook **must not** be `async`; any async work should be scheduled manually.
          */
-        hasConsent(name: string): boolean;
+        readonly onBlocked?: BlockHandler | (keyof T & (string | symbol));
+    }
+
+    export declare const HoverBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        componentId: z.ZodMiniString<string>;
+        experienceId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        variantIndex: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        hoverId: z.ZodMiniString<string>;
+        hoverDurationMs: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing entry hover events.
+     *
+     * @public
+     */
+    export declare type HoverBuilderArgs = z.infer<typeof HoverBuilderArgs>;
+
+    export declare const IdentifyBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        traits: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniJSONSchema>>;
+        userId: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing identify events.
+     *
+     * @remarks
+     * Traits are merged by the API; only specified properties may be overwritten.
+     *
+     * @public
+     */
+    export declare type IdentifyBuilderArgs = z.infer<typeof IdentifyBuilderArgs>;
+
+    /**
+     * Internal Insights queueing and flush runtime used by {@link CoreStateful}.
+     *
+     * @internal
+     */
+    declare class InsightsQueue {
+        private readonly eventInterceptors;
+        private readonly flushIntervalMs;
+        private readonly flushRuntime;
+        private readonly insightsApi;
+        private readonly queuedInsightsByProfile;
+        private insightsPeriodicFlushTimer;
+        constructor(options: InsightsQueueOptions);
+        clearScheduledRetry(): void;
+        clearPeriodicFlushTimer(): void;
+        send(event: InsightsEvent): Promise<void>;
+        flush(options?: {
+            force?: boolean;
+        }): Promise<void>;
+        private createBatches;
+        private trySendBatches;
+        private getQueuedEventCount;
+        private ensurePeriodicFlushTimer;
+        private reconcilePeriodicFlushTimer;
+    }
+
+    declare interface InsightsQueueOptions {
+        eventInterceptors: LifecycleInterceptors['event'];
+        flushPolicy: ResolvedQueueFlushPolicy;
+        insightsApi: {
+            sendBatchEvents: (batches: BatchInsightsEventArray) => Promise<boolean>;
+        };
+    }
+
+    /**
+     * A function that receives a value of type `T` and returns a (possibly async)
+     * value of the same type `T`. The input is marked as `readonly` to discourage
+     * mutation of the original object.
+     *
+     * @typeParam T - The value type intercepted and returned.
+     * @param value - The current (readonly) value in the interception chain.
+     * @returns The next value for the chain, either directly or via a promise.
+     * @remarks Implementations SHOULD avoid mutating `value` and instead return a
+     * new or safely-updated instance.
+     * @see {@link InterceptorManager}
+     * @public
+     */
+    export declare type Interceptor<T> = (value: Readonly<T>) => MaybePromise<T>;
+
+    /**
+     * Manages a list of interceptors and provides a way to run them in sequence.
+     *
+     * Interceptors are executed in insertion order. Each interceptor receives the
+     * result of the previous interceptor (or the initial input for the first one)
+     * and may return a new value synchronously or asynchronously.
+     *
+     * @typeParam T - The value type processed by the interceptors.
+     * @remarks This class snapshots the current interceptor list at invocation time
+     * so additions/removals during `run` do not affect the in-flight execution.
+     * @example
+     * ```ts
+     * const mgr = new InterceptorManager<number>();
+     * const id = mgr.add((n) => n + 1);
+     * const final = await mgr.run(1); // 2
+     * mgr.remove(id);
+     * ```
+     * @public
+     */
+    export declare class InterceptorManager<T> {
         /**
-         * Hook invoked when an operation is blocked due to missing consent.
+         * The registry of interceptors keyed by their insertion id.
          *
-         * @param name - The blocked operation name.
-         * @param payload - The original arguments supplied to the operation.
-         * @example
-         * ```ts
-         * personalization.onBlockedByConsent('track', [payload])
-         * ```
+         * @privateRemarks Internal storage; use {@link add}, {@link remove}, and
+         * {@link clear} to manage contents.
+         * @readonly
+         * @defaultValue `new Map()`
          */
-        onBlockedByConsent(name: string, payload: readonly unknown[]): void;
+        private readonly interceptors;
         /**
-         * Identify the current profile/visitor to associate traits with a profile
-         * and update optimization state.
+         * The next numeric id to assign to an added interceptor.
          *
-         * @param payload - Identify builder payload.
-         * @returns The resulting {@link OptimizationData} for the identified user.
-         * @example
-         * ```ts
-         * const data = await personalization.identify({ userId: 'user-123' })
-         * ```
+         * @privateRemarks Used only to generate unique, monotonically increasing ids.
+         * @defaultValue `0`
          */
-        identify(payload: IdentifyBuilderArgs): Promise<OptimizationData | undefined>;
+        private nextId;
         /**
-         * Record a page view and update optimization state.
+         * Add an interceptor and return its identifier.
          *
-         * @param payload - Page view builder payload.
-         * @returns The evaluated {@link OptimizationData} for this page view.
+         * @param interceptor - The interceptor function to register.
+         * @returns The numeric id that can later be used with {@link remove}.
+         * @remarks Interceptors are executed in the order they are added.
          * @example
          * ```ts
-         * const data = await personalization.page({ properties: { title: 'Home' } })
+         * const id = manager.add(async (value) => transform(value));
          * ```
+         * @public
          */
-        page(payload: PageViewBuilderArgs): Promise<OptimizationData | undefined>;
+        add(interceptor: Interceptor<T>): number;
         /**
-         * Record a screen view and update optimization state.
+         * Remove an interceptor by its identifier.
          *
-         * @param payload - Screen view builder payload.
-         * @returns The evaluated {@link OptimizationData} for this screen view.
+         * @param id - The id previously returned by {@link add}.
+         * @returns `true` if an interceptor was removed; otherwise `false`.
          * @example
          * ```ts
-         * const data = await personalization.screen({ name: 'HomeScreen' })
+         * const removed = manager.remove(id);
          * ```
+         * @public
          */
-        screen(payload: ScreenViewBuilderArgs): Promise<OptimizationData | undefined>;
+        remove(id: number): boolean;
         /**
-         * Record a custom track event and update optimization state.
+         * Remove all registered interceptors.
          *
-         * @param payload - Track builder payload.
-         * @returns The evaluated {@link OptimizationData} for this event.
+         * @returns Nothing.
+         * @remarks After calling this, {@link count} will return `0`.
          * @example
          * ```ts
-         * const data = await personalization.track({ event: 'button_click' })
+         * manager.clear();
          * ```
+         * @public
          */
-        track(payload: TrackBuilderArgs): Promise<OptimizationData | undefined>;
+        clear(): void;
         /**
-         * Record a "sticky" component view and update optimization state.
+         * Get the number of currently registered interceptors.
          *
-         * @param payload - Component view builder payload.
-         * @returns The evaluated {@link OptimizationData} for this component view.
+         * @returns The count of interceptors.
          * @example
          * ```ts
-         * const data = await personalization.trackComponentView({ componentId: 'hero-banner' })
+         * if (manager.count() === 0) { /* ... *\/ }
          * ```
+         * @public
          */
-        trackComponentView(payload: ComponentViewBuilderArgs): Promise<OptimizationData | undefined>;
-        /**
-         * Intercept, validate, and place an event into the offline event queue; then
-         * trigger a size‑based flush if necessary.
-         *
-         * @param event - The event to enqueue.
-         */
-        private sendOrEnqueueEvent;
-        /**
-         * Enqueue an offline event, dropping oldest events first when queue bounds are reached.
-         *
-         * @param event - Event to enqueue.
-         */
-        private enqueueOfflineEvent;
-        /**
-         * Drop oldest offline events from the queue.
-         *
-         * @param count - Number of oldest events to drop.
-         * @returns Dropped events in oldest-first order.
-         */
-        private dropOldestOfflineEvents;
-        /**
-         * Invoke offline queue drop callback in a fault-tolerant manner.
-         *
-         * @param context - Drop callback payload.
-         */
-        private invokeQueueDropCallback;
+        count(): number;
         /**
-         * Flush the offline queue
+         * Run all interceptors in sequence on an input value and return the final result.
          *
-         * @param options - Optional flush controls.
-         * @param options.force - When `true`, bypass offline/backoff/circuit gates and attempt immediately.
+         * Supports both sync and async interceptors; the return type is always `Promise<T>`
+         * for consistency.
          *
+         * @param input - The initial value to pass to the first interceptor.
+         * @returns A promise resolving to the final value after all interceptors have run.
+         * @throws May rethrow any error thrown by an interceptor. <!-- Intentionally vague: error type depends on interceptor implementation -->
+         * @remarks The interceptor list is snapshotted at invocation time; changes to
+         * the registry during execution do not affect the running sequence.
          * @example
          * ```ts
-         * await personalization.flush()
-         */
-        flush(options?: {
-            force?: boolean;
-        }): Promise<void>;
-        /**
-         * Flush queued offline events using retry/circuit guards.
-         *
-         * @param options - Flush controls.
-         * @param options.force - When true, bypass online/backoff/circuit gates.
-         */
-        private flushOfflineQueue;
-        /**
-         * Attempt to send queued events to the Experience API.
-         *
-         * @param events - Snapshot of queued events to send.
-         * @returns `true` when send succeeds; otherwise `false`.
-         */
-        private tryUpsertQueuedEvents;
-        /**
-         * Submit events to the Experience API, updating output signals with the
-         * returned state.
-         *
-         * @param events - The events to submit.
-         * @returns The {@link OptimizationData} returned by the service.
-         * @internal
-         * @privateRemarks
-         * If a `getAnonymousId` function has been provided, the returned value will
-         * take precedence over the `id` property of the current {@link Profile}
-         * signal value
-         */
-        private upsertProfile;
-        /**
-         * Apply returned optimization state to local signals after interceptor processing.
-         *
-         * @param data - Optimization state returned by the service.
-         * @internal
+         * const result = await manager.run(initial);
+         * ```
+         * @public
          */
-        private updateOutputSignals;
+        run(input: T): Promise<T>;
+    }
+
+    /**
+     * Lifecycle container for event and state interceptors.
+     *
+     * @public
+     */
+    export declare interface LifecycleInterceptors {
+        /** Interceptors invoked for individual events prior to validation/sending. */
+        event: InterceptorManager<InsightsEvent | ExperienceEvent>;
+        /** Interceptors invoked before optimization state updates. */
+        state: InterceptorManager<OptimizationData>;
     }
 
     /**
-     * Options for configuring {@link PersonalizationStateful} functionality.
+     * A utility type representing a value that may be synchronously available or
+     * produced asynchronously.
      *
+     * @typeParam T - The resolved value type.
      * @public
-     * @see {@link ProductBaseOptions}
      */
-    export declare type PersonalizationStatefulOptions = ProductBaseOptions & {
-        /** Configuration specific to the Personalization product */
-        config?: PersonalizationProductConfig;
-    };
+    export declare type MaybePromise<T> = T | Promise<T>;
 
     /**
-     * Stateless personalization implementation that immediately validates and sends
-     * a single event to the Experience API, upserting the profile as needed.
+     * Resolves merge tag values from a {@link Profile}.
      *
      * @public
      * @remarks
-     * Each public method constructs a strongly-typed event via the shared builder,
-     * runs it through event interceptors, and performs a profile upsert using the
-     * Experience API. If an anonymous ID is available from the builder, it will be
-     * preferred as the `profileId` unless an explicit profile is provided.
+     * *Merge tags* are references to user profile data that may be embedded in content
+     * and expanded at runtime. This resolver normalizes the merge-tag identifier into
+     * a set of candidate selectors and searches the profile for a matching value.
+     * Result values are returned as strings; numeric/boolean primitives are stringified.
      */
-    export declare class PersonalizationStateless extends PersonalizationBase {
+    export declare const MergeTagValueResolver: {
         /**
-         * Identify the current profile/visitor to associate traits with a profile.
+         * Generate a list of candidate selectors for a merge-tag ID.
          *
-         * @param payload - Identify builder arguments with an optional partial
-         * profile to attach to the upsert request.
-         * @returns The resulting {@link OptimizationData} for the identified user.
+         * @param id - Merge-tag identifier (segments separated by `_`).
+         * @returns Array of dot-path selectors to try against a profile.
          * @example
          * ```ts
-         * const data = await personalization.identify({ userId: 'user-123', profile: { id: 'anon-1' } })
+         * // "profile_name_first" -> [
+         * //   'profile',
+         * //   'profile.name',
+         * //   'profile.name.first'
+         * // ]
+         * const selectors = MergeTagValueResolver.normalizeSelectors('profile_name_first')
          * ```
          */
-        identify(payload: IdentifyBuilderArgs & {
-            profile?: PartialProfile;
-        }): Promise<OptimizationData>;
+        normalizeSelectors(id: string): string[];
         /**
-         * Record a page view.
+         * Look up a merge-tag value from a profile using normalized selectors.
          *
-         * @param payload - Page view builder arguments with an optional partial profile.
-         * @returns The evaluated {@link OptimizationData} for this page view.
+         * @param id - Merge-tag identifier.
+         * @param profile - Profile from which to resolve the value.
+         * @returns A stringified primitive if found; otherwise `undefined`.
+         * @remarks
+         * Only string/number/boolean primitives are returned; objects/arrays are ignored.
          * @example
          * ```ts
-         * const data = await personalization.page({ properties: { title: 'Home' }, profile: { id: 'anon-1' } })
+         * const value = MergeTagValueResolver.getValueFromProfile('user_email', profile)
+         * if (value) sendEmailTo(value)
          * ```
          */
-        page(payload: PageViewBuilderArgs & {
-            profile?: PartialProfile;
-        }): Promise<OptimizationData>;
+        getValueFromProfile(id: string, profile?: Profile): string | undefined;
         /**
-         * Record a screen view.
+         * Resolve the display value for a merge-tag entry using the provided profile,
+         * falling back to the entry's configured `nt_fallback` when necessary.
          *
-         * @param payload - Screen view builder arguments with an optional partial profile.
-         * @returns The evaluated {@link OptimizationData} for this screen view.
+         * @param mergeTagEntry - The merge-tag entry to resolve.
+         * @param profile - Optional profile used for lookup.
+         * @returns The resolved string, or `undefined` if the entry is invalid and no
+         * fallback is available.
+         * @remarks
+         * The resolved value depends on the current request profile, so callers
+         * should not reuse rendered output across users or requests unless the
+         * cache varies on the same profile inputs.
          * @example
          * ```ts
-         * const data = await personalization.screen({ name: 'HomeScreen', profile: { id: 'anon-1' } })
+         * const text = MergeTagValueResolver.resolve(entry, profile)
+         * render(text ?? 'Guest')
          * ```
          */
-        screen(payload: ScreenViewBuilderArgs & {
-            profile?: PartialProfile;
-        }): Promise<OptimizationData>;
+        resolve(mergeTagEntry: MergeTagEntry | undefined, profile?: Profile): string | undefined;
+    };
+
+    /**
+     * Minimal observable contract used by stateful Core signal streams.
+     *
+     * @typeParam T - Value type emitted by the observable.
+     * @public
+     */
+    export declare interface Observable<T> {
         /**
-         * Record a custom track event.
+         * Deep-cloned snapshot of the current signal value.
          *
-         * @param payload - Track builder arguments with an optional partial profile.
-         * @returns The evaluated {@link OptimizationData} for this event.
-         * @example
-         * ```ts
-         * const data = await personalization.track({ event: 'purchase', profile: { id: 'anon-1' } })
-         * ```
+         * @remarks
+         * A clone is returned to prevent accidental in-place mutations from leaking
+         * back into internal signal state.
          */
-        track(payload: TrackBuilderArgs & {
-            profile?: PartialProfile;
-        }): Promise<OptimizationData>;
+        readonly current: T;
         /**
-         * Record a "sticky" component view.
+         * Subscribe to all value updates (including the current value immediately).
          *
-         * @param payload - Component view builder arguments with an optional partial profile.
-         * @returns The evaluated {@link OptimizationData} for this component view.
-         * @example
-         * ```ts
-         * const data = await personalization.trackComponentView({ componentId: 'hero', profile: { id: 'anon-1' } })
-         * ```
+         * @param next - Callback invoked for each emitted value snapshot.
+         * @returns A {@link Subscription} used to stop observing updates.
+         *
+         * @remarks
+         * Values are deep-cloned before being passed to `next`.
          */
-        trackComponentView(payload: ComponentViewBuilderArgs & {
-            profile?: PartialProfile;
-        }): Promise<OptimizationData>;
+        subscribe: (next: (v: T) => void) => Subscription;
         /**
-         * Intercept, validate, and upsert the profile with a single personalization
-         * event.
+         * Subscribe to the first non-nullish value, then auto-unsubscribe.
          *
-         * @param event - The {@link PersonalizationEvent} to submit.
-         * @param profile - Optional partial profile. If omitted, the anonymous ID from
-         * the builder (when present) is used as the `profileId`.
-         * @returns The {@link OptimizationData} returned by the Experience API.
-         * @internal
+         * @param next - Callback invoked exactly once with the first non-nullish value.
+         * @returns A {@link Subscription} that can cancel before the first emission.
+         *
+         * @remarks
+         * Values are deep-cloned before being passed to `next`.
          */
-        private upsertProfile;
+        subscribeOnce: (next: (v: NonNullable<T>) => void) => Subscription;
     }
 
     /**
-     * Observables exposed by {@link PersonalizationStateful} that mirror internal signals.
+     * Runtime online/offline signal used by queue flush logic.
      *
+     * @defaultValue `true`
      * @public
      */
-    export declare interface PersonalizationStates {
-        /** Observable stream of the latest blocked event payload (or `undefined`). */
-        blockedEventStream: Observable<BlockedEvent | undefined>;
-        /** Observable stream of the latest {@link AnalyticsEvent} or {@link PersonalizationEvent} (or `undefined`). */
-        eventStream: Observable<InsightsEvent | ExperienceEvent | undefined>;
-        /** Live view of effective flags for the current profile (if available). */
-        flags: Observable<Flags | undefined>;
-        /** Live view of the current profile. */
-        profile: Observable<Profile | undefined>;
-        /** Live view of selected personalizations (variants). */
-        personalizations: Observable<SelectedPersonalizationArray | undefined>;
-    }
+    declare const online: Signal<boolean | undefined>;
 
     /**
-     * Resolve a personalized Contentful entry to the correct variant for the current
+     * The package name of the Optimization Core SDK, injected at build time.
+     *
+     * @public
+     */
+    export declare const OPTIMIZATION_CORE_SDK_NAME: string;
+
+    /**
+     * The current version of the Optimization Core SDK, injected at build time.
+     *
+     * @public
+     */
+    export declare const OPTIMIZATION_CORE_SDK_VERSION: string;
+
+    /**
+     * Resolve an optimized Contentful entry to the correct variant for the current
      * selections.
      *
      * @public
      * @remarks
-     * Given a baseline {@link PersonalizedEntry} and a set of selected personalizations
+     * Given a baseline {@link OptimizedEntry} and a set of selected optimizations
      * (variants per experience), this resolver finds the matching replacement variant
      * for the component configured against the baseline entry.
      *
-     * **Variant indexing**: `variantIndex` in {@link SelectedPersonalization} is treated as
+     * **Variant indexing**: `variantIndex` in {@link SelectedOptimization} is treated as
      * 1‑based (index 1 = first variant). A value of `0` indicates baseline.
      */
-    export declare const PersonalizedEntryResolver: {
+    export declare const OptimizedEntryResolver: {
         /**
-         * Find the personalization entry corresponding to one of the selected experiences.
+         * Find the optimization entry corresponding to one of the selected experiences.
          *
-         * @param params - Object containing the baseline personalized entry and the selections.
+         * @param params - Object containing the baseline optimized entry and the selections.
          * @param skipValidation - When `true`, skip type/shape validation for perf.
-         * @returns The matching {@link PersonalizationEntry}, or `undefined` if not found/invalid.
+         * @returns The matching {@link OptimizationEntry}, or `undefined` if not found/invalid.
          * @remarks
-         * A personalization entry is a personalization configuration object supplied in a
-         * `PersonalizedEntry.nt_experiences` array. A personalized entry may relate to
-         * multiple personalizations.
+         * An optimization entry is an optimization configuration object supplied in an
+         * `OptimizedEntry.nt_experiences` array. An optimized entry may relate to
+         * multiple optimizations.
          * @example
          * ```ts
-         * const personalizationEntry = PersonalizedEntryResolver.getPersonalizationEntry({
-         *   personalizedEntry: entry,
-         *   selectedPersonalizations
+         * const optimizationEntry = OptimizedEntryResolver.getOptimizationEntry({
+         *   optimizedEntry: entry,
+         *   selectedOptimizations
          * })
          * ```
          */
-        getPersonalizationEntry({ personalizedEntry, selectedPersonalizations, }: {
-            personalizedEntry: PersonalizedEntry_2;
-            selectedPersonalizations: SelectedPersonalizationArray;
-        }, skipValidation?: boolean): PersonalizationEntry_2 | undefined;
+        getOptimizationEntry({ optimizedEntry, selectedOptimizations, }: {
+            optimizedEntry: OptimizedEntry_2;
+            selectedOptimizations: SelectedOptimizationArray;
+        }, skipValidation?: boolean): OptimizationEntry_2 | undefined;
         /**
-         * Look up the selection metadata for a specific personalization entry.
+         * Look up the selection metadata for a specific optimization entry.
          *
-         * @param params - Object with the target personalization entry and selections.
+         * @param params - Object with the target optimization entry and selections.
          * @param skipValidation - When `true`, skip type checks.
-         * @returns The matching {@link SelectedPersonalization}, if present.
+         * @returns The matching {@link SelectedOptimization}, if present.
          * @remarks
-         * Selected personalizations are supplied by the Experience API in the
+         * Selected optimizations are supplied by the Experience API in the
          * `experiences` response data property.
          * @example
          * ```ts
-         * const selectedPersonalization = PersonalizedEntryResolver.getSelectedPersonalization({
-         *   personalizationEntry,
-         *   selectedPersonalizations
+         * const selectedOptimization = OptimizedEntryResolver.getSelectedOptimization({
+         *   optimizationEntry,
+         *   selectedOptimizations
          * })
          * ```
          */
-        getSelectedPersonalization({ personalizationEntry, selectedPersonalizations, }: {
-            personalizationEntry: PersonalizationEntry_2;
-            selectedPersonalizations: SelectedPersonalizationArray;
-        }, skipValidation?: boolean): SelectedPersonalization | undefined;
+        getSelectedOptimization({ optimizationEntry, selectedOptimizations, }: {
+            optimizationEntry: OptimizationEntry_2;
+            selectedOptimizations: SelectedOptimizationArray;
+        }, skipValidation?: boolean): SelectedOptimization_2 | undefined;
         /**
          * Get the replacement variant config for the given selection index.
          *
-         * @param params - Baseline entry, personalization entry, and 1‑based variant index.
+         * @param params - Baseline entry, optimization entry, and 1‑based variant index.
          * @param skipValidation - When `true`, skip type checks.
          * @returns The {@link EntryReplacementVariant} for the component, if any.
          * @remarks
          * Entry replacement variants are variant configurations specified in a
-         * personalization configuration component's `variants` array supplied by the
-         * personalized entry via its `nt_config` field.
+         * optimization configuration component's `variants` array supplied by the
+         * optimized entry via its `nt_config` field.
          * @example
          * ```ts
-         * const selectedVariant = PersonalizedEntryResolver.getSelectedVariant({
-         *   personalizedEntry: entry,
-         *   personalizationEntry,
+         * const selectedVariant = OptimizedEntryResolver.getSelectedVariant({
+         *   optimizedEntry: entry,
+         *   optimizationEntry,
          *   selectedVariantIndex: 2 // second variant (1‑based)
          * })
          * ```
          */
-        getSelectedVariant({ personalizedEntry, personalizationEntry, selectedVariantIndex, }: {
-            personalizedEntry: PersonalizedEntry_2;
-            personalizationEntry: PersonalizationEntry_2;
+        getSelectedVariant({ optimizedEntry, optimizationEntry, selectedVariantIndex, }: {
+            optimizedEntry: OptimizedEntry_2;
+            optimizationEntry: OptimizationEntry_2;
             selectedVariantIndex: number;
         }, skipValidation?: boolean): EntryReplacementVariant_2 | undefined;
         /**
@@ -2078,44 +1874,83 @@ declare abstract class CoreBase implements ResolverMethods {
          * @typeParam S - Entry skeleton type.
          * @typeParam M - Chain modifiers.
          * @typeParam L - Locale code.
-         * @param params - Personalization entry and selected variant.
+         * @param params - Optimization entry and selected variant.
          * @param skipValidation - When `true`, skip type checks.
          * @returns The resolved entry typed as {@link Entry} or `undefined`.
          * @remarks
-         * A personalized entry will resolve either to the baseline (the entry
-         * supplied as `personalizedEntry`) or the selected variant.
+         * An optimized entry will resolve either to the baseline (the entry
+         * supplied as `optimizedEntry`) or the selected variant.
          * @example
          * ```ts
-         * const selectedVariantEntry = PersonalizedEntryResolver.getSelectedVariantEntry<{ fields: unknown }>({
-         *   personalizationEntry,
+         * const selectedVariantEntry = OptimizedEntryResolver.getSelectedVariantEntry<{ fields: unknown }>({
+         *   optimizationEntry,
          *   selectedVariant
          * })
          * ```
          */
-        getSelectedVariantEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>({ personalizationEntry, selectedVariant, }: {
-            personalizationEntry: PersonalizationEntry_2;
+        getSelectedVariantEntry<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>({ optimizationEntry, selectedVariant, }: {
+            optimizationEntry: OptimizationEntry_2;
             selectedVariant: EntryReplacementVariant_2;
         }, skipValidation?: boolean): Entry<S, M, L> | undefined;
-        /**
-         * Resolve the selected entry (baseline or variant) for a personalized entry
-         * and optional selected personalizations, returning both the entry and the
-         * personalization metadata.
-         *
-         * @typeParam S - Entry skeleton type.
-         * @typeParam M - Chain modifiers.
-         * @typeParam L - Locale code.
-         * @param entry - The baseline personalized entry.
-         * @param selectedPersonalizations - Optional selections for the current profile.
-         * @returns An object containing the resolved entry and (if chosen) the selection.
-         * @example
-         * ```ts
-         * const { entry: personalizedEntry, personalization } = PersonalizedEntryResolver.resolve(entry, selections)
-         * if (personalization) console.log('Variant index', personalization.variantIndex)
-         * ```
-         */
-        resolve<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = string>(entry: Entry<S, M, L>, selectedPersonalizations?: SelectedPersonalizationArray): ResolvedData<S, M, L>;
+        resolve: typeof resolve;
     };
 
+    export declare const PageViewBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        properties: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            query: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+            referrer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            search: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            title: z.ZodMiniOptional<z.ZodMiniOptional<z.ZodMiniString<string>>>;
+            url: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing page view events.
+     *
+     * @remarks
+     * Any properties passed here are merged with the base page properties from
+     * {@link EventBuilderConfig.getPageProperties}.
+     *
+     * @public
+     */
+    export declare type PageViewBuilderArgs = z.infer<typeof PageViewBuilderArgs>;
+
     export declare const PREVIEW_PANEL_SIGNAL_FNS_SYMBOL: unique symbol;
 
     /**
@@ -2125,8 +1960,20 @@ declare abstract class CoreBase implements ResolverMethods {
      */
     export declare const PREVIEW_PANEL_SIGNALS_SYMBOL: unique symbol;
 
+    /**
+     * Indicates whether the preview panel bridge has been attached.
+     *
+     * @defaultValue `false`
+     * @public
+     */
     declare const previewPanelAttached: Signal<boolean>;
 
+    /**
+     * Indicates whether the preview panel is currently open.
+     *
+     * @defaultValue `false`
+     * @public
+     */
     declare const previewPanelOpen: Signal<boolean>;
 
     /**
@@ -2142,84 +1989,10 @@ declare abstract class CoreBase implements ResolverMethods {
     }
 
     /**
-     * Shared base for all product implementations.
-     *
-     * @internal
-     * @remarks
-     * This abstract class is not exported as part of the public API surface.
-     * Concrete implementations (e.g., analytics) should extend this class and
-     * expose their own public methods.
-     */
-    declare abstract class ProductBase {
-        /**
-         * Allow‑list of event {@link AnalyticsEventType | type keys} permitted when consent is not present.
-         */
-        protected readonly allowedEventTypes?: string[];
-        /** Event builder used to construct strongly‑typed events. */
-        protected readonly builder: EventBuilder;
-        /** Optimization API client used to send events to the Experience and Insights APIs. */
-        protected readonly api: ApiClient;
-        /** Interceptors that can mutate/augment outgoing events or optimization state. */
-        readonly interceptors: LifecycleInterceptors;
-        /** Optional callback invoked when an event call is blocked. */
-        protected readonly onEventBlocked?: ProductConfig['onEventBlocked'];
-        /**
-         * Creates a new product base instance.
-         *
-         * @param options - Options for configuring the functionality common among products.
-         */
-        constructor(options: ProductBaseOptions);
-        /**
-         * Publish blocked event metadata to both callback and blocked event signal.
-         *
-         * @param reason - Reason the method call was blocked.
-         * @param product - Product that blocked the method call.
-         * @param method - Name of the blocked method.
-         * @param args - Original blocked call arguments.
-         */
-        protected reportBlockedEvent(reason: BlockedEventReason, product: BlockedEventProduct, method: string, args: readonly unknown[]): void;
-    }
-
-    /**
-     * Options for configuring the common functionality of {@link ProductBase} descendents.
-     *
-     * @public
-     */
-    declare interface ProductBaseOptions {
-        /** Optimization API client. */
-        api: ApiClient;
-        /** Event builder for constructing events. */
-        builder: EventBuilder;
-        /** Optional configuration for allow‑lists and guard callbacks. */
-        config?: ProductConfig;
-        /** Lifecycle container for event and state interceptors. */
-        interceptors: LifecycleInterceptors;
-    }
-
-    /**
-     * Common configuration for all product implementations.
+     * Active profile associated with current runtime state.
      *
      * @public
      */
-    declare interface ProductConfig {
-        /**
-         * The set of event type strings that are allowed to be sent even if consent is
-         * not granted.
-         *
-         * @defaultValue `['identify', 'page', 'screen']`
-         * @remarks These types are compared against the `type` property of events.
-         */
-        allowedEventTypes?: EventType[];
-        /**
-         * Callback invoked whenever an event call is blocked by guards.
-         *
-         * @remarks
-         * This callback is best-effort. Any exception thrown by the callback is
-         * swallowed to keep event handling fault tolerant.
-         */
-        onEventBlocked?: (event: BlockedEvent) => void;
-    }
-
     declare const profile: Signal<Profile | undefined>;
 
     /**
@@ -2234,7 +2007,7 @@ declare abstract class CoreBase implements ResolverMethods {
      *
      * @public
      */
-    declare interface QueueFlushFailureContext {
+    export declare interface QueueFlushFailureContext {
         /** Number of consecutive failed flush attempts. */
         consecutiveFailures: number;
         /** Number of queued batches at the time of the failed attempt. */
@@ -2250,7 +2023,13 @@ declare abstract class CoreBase implements ResolverMethods {
      *
      * @public
      */
-    declare interface QueueFlushPolicy {
+    export declare interface QueueFlushPolicy {
+        /**
+         * Periodic flush interval in milliseconds while events remain queued.
+         *
+         * @defaultValue `30000`
+         */
+        flushIntervalMs?: number;
         /**
          * Base retry backoff delay in milliseconds.
          *
@@ -2303,13 +2082,53 @@ declare abstract class CoreBase implements ResolverMethods {
      *
      * @public
      */
-    declare interface QueueFlushRecoveredContext {
+    export declare interface QueueFlushRecoveredContext {
         /** Consecutive failure count that existed immediately before recovery. */
         consecutiveFailures: number;
     }
 
     /**
-     * Result returned by {@link PersonalizedEntryResolver.resolve}.
+     * Unified queue policy for stateful Core.
+     *
+     * @public
+     */
+    export declare interface QueuePolicy {
+        /** Shared retry/backoff/circuit policy for queued flushes. */
+        flush?: QueueFlushPolicy;
+        /** Maximum number of offline Experience events retained. */
+        offlineMaxEvents?: number;
+        /** Callback invoked when oldest offline Experience events are dropped. */
+        onOfflineDrop?: (context: ExperienceQueueDropContext) => void;
+    }
+
+    /**
+     * Resolve the selected entry (baseline or variant) for an optimized entry
+     * and optional selected optimizations, returning both the entry and the
+     * optimization metadata.
+     *
+     * @typeParam S - Entry skeleton type.
+     * @typeParam L - Locale code.
+     * @typeParam M - Chain modifiers for advanced/non-default Contentful clients.
+     * @param entry - The baseline optimized entry.
+     * @param selectedOptimizations - Optional selections for the current profile.
+     * @returns An object containing the resolved entry and (if chosen) the selection.
+     * @example
+     * ```ts
+     * const { entry: optimizedEntry, selectedOptimization } = OptimizedEntryResolver.resolve(
+     *   entry,
+     *   selections,
+     * )
+     * if (selectedOptimization) {
+     *   console.log('Variant index', selectedOptimization.variantIndex)
+     * }
+     * ```
+     */
+    declare function resolve<S extends EntrySkeletonType = EntrySkeletonType, L extends LocaleCode = LocaleCode>(entry: Entry<S, undefined, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, undefined, L>;
+
+    declare function resolve<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode>(entry: Entry<S, M, L>, selectedOptimizations?: SelectedOptimizationArray): ResolvedData<S, M, L>;
+
+    /**
+     * Result returned by {@link OptimizedEntryResolver.resolve}.
      *
      * @typeParam S - Entry skeleton type.
      * @typeParam M - Chain modifiers.
@@ -2319,114 +2138,358 @@ declare abstract class CoreBase implements ResolverMethods {
     export declare interface ResolvedData<S extends EntrySkeletonType, M extends ChainModifiers = ChainModifiers, L extends LocaleCode = LocaleCode> {
         /** The baseline or resolved variant entry. */
         entry: Entry<S, M, L>;
-        /** The selected personalization metadata, if a non‑baseline variant was chosen. */
-        personalization?: SelectedPersonalization;
+        /** The selected optimization metadata, if a non-baseline variant was chosen. */
+        selectedOptimization?: SelectedOptimization_2;
     }
 
     /**
-     * These methods assist in resolving values via Resolvers
+     * Internal normalized shape of queue flush policy values.
      *
      * @internal
-     * @privateRemarks
-     * This interface exists to document that the included methods should not be
-     * considered static.
      */
-    export declare interface ResolverMethods {
-        /**
-         * Get the specified Custom Flag's value from the supplied changes.
-         * @param name - The name or key of the Custom Flag.
-         * @param changes - Optional changes array.
-         * @returns The current value of the Custom Flag if found.
-         * @remarks
-         * The changes array can be sourced from the data returned when emitting any
-         * personalization event.
-         * */
-        getCustomFlag: (name: string, changes?: ChangeArray) => Json;
-        /**
-         * Get all resolved Custom Flags from the supplied changes.
-         * @param changes - Optional changes array.
-         * @returns The resolved Custom Flag map.
-         * @remarks
-         * The changes array can be sourced from the data returned when emitting any
-         * personalization event.
-         * */
-        getCustomFlags: (changes?: ChangeArray) => Flags;
-        /**
-         * Resolve a Contentful entry to a personalized variant using the current
-         * or provided selected personalizations.
-         *
-         * @typeParam S - Entry skeleton type.
-         * @typeParam M - Chain modifiers.
-         * @typeParam L - Locale code.
-         * @param entry - The entry to personalize.
-         * @param personalizations - Optional selections.
-         * @returns The resolved entry data.
-         * @remarks
-         * Selected personalizations can be sourced from the data returned when emitting any
-         * personalization event.
-         */
-        personalizeEntry: <S extends EntrySkeletonType, M extends ChainModifiers, L extends LocaleCode>(entry: Entry<S, M, L>, personalizations?: SelectedPersonalizationArray) => ResolvedData<S, M, L>;
-        /**
-         * Resolve a merge tag to a value based on the current (or provided) profile.
-         *
-         * @param embeddedEntryNodeTarget - The merge‑tag entry node to resolve.
-         * @param profile - Optional profile.
-         * @returns The resolved value (type depends on the tag).
-         * @remarks
-         * Merge tags are references to profile data that can be substituted into content. The
-         * profile can be sourced from the data returned when emitting any personalization event.
-         */
-        getMergeTagValue: (embeddedEntryNodeTarget: MergeTagEntry, profile?: Profile) => string | undefined;
+    declare interface ResolvedQueueFlushPolicy {
+        flushIntervalMs: number;
+        baseBackoffMs: number;
+        maxBackoffMs: number;
+        jitterRatio: number;
+        maxConsecutiveFailures: number;
+        circuitOpenMs: number;
+        onCircuitOpen?: QueueFlushPolicy['onCircuitOpen'];
+        onFlushFailure?: QueueFlushPolicy['onFlushFailure'];
+        onFlushRecovered?: QueueFlushPolicy['onFlushRecovered'];
     }
 
+    export declare const ScreenViewBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        name: z.ZodMiniString<string>;
+        properties: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniJSONSchema>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing screen view events.
+     *
+     * @remarks
+     * Any properties passed here are merged with the base screen properties supplied
+     * by the runtime.
+     *
+     * @public
+     */
+    export declare type ScreenViewBuilderArgs = z.infer<typeof ScreenViewBuilderArgs>;
+
+    /**
+     * Storage key for cached selected optimizations.
+     *
+     * @internal
+     */
+    export declare const SELECTED_OPTIMIZATIONS_CACHE_KEY = "__ctfl_opt_selected-optimizations__";
+
+    /**
+     * Latest selected optimization variants.
+     *
+     * @public
+     */
+    declare const selectedOptimizations: Signal<{
+        experienceId: string;
+        variantIndex: number;
+        variants: Record<string, string>;
+        sticky?: boolean | undefined;
+    }[] | undefined>;
+
     export { Signal }
 
+    /**
+     * Signal utility functions shared with preview tooling and extensions.
+     *
+     * @public
+     */
     export declare interface SignalFns {
+        /** Execute multiple signal writes in one reactive batch. */
         batch: typeof batch;
+        /** Create a derived computed signal. */
         computed: typeof computed;
+        /** Register a reactive effect. */
         effect: typeof effect;
+        /** Read signal values without dependency tracking. */
         untracked: typeof untracked;
     }
 
+    /**
+     * Pre-bundled reference to shared signal helpers.
+     *
+     * @public
+     */
     export declare const signalFns: SignalFns;
 
+    /**
+     * Collection of shared stateful Core signals.
+     *
+     * @public
+     */
     export declare interface Signals {
+        /** Most recent blocked-event metadata. */
         blockedEvent: typeof blockedEvent;
+        /** Latest optimization changes payload. */
         changes: typeof changes;
+        /** Current consent signal. */
         consent: typeof consent;
+        /** Most recent emitted event signal. */
         event: typeof event_2;
-        flags: typeof flags;
+        /** Runtime connectivity signal. */
         online: typeof online;
+        /** Preview panel attachment signal. */
         previewPanelAttached: typeof previewPanelAttached;
+        /** Preview panel open-state signal. */
         previewPanelOpen: typeof previewPanelOpen;
-        personalizations: typeof personalizations;
+        /** Selected optimization variants signal. */
+        selectedOptimizations: typeof selectedOptimizations;
+        /** Whether optimization selection data is currently available. */
+        canOptimize: typeof canOptimize;
+        /** Active profile signal. */
         profile: typeof profile;
     }
 
+    /**
+     * Pre-bundled reference to all shared signals.
+     *
+     * @public
+     */
     export declare const signals: Signals;
 
-    declare interface Subscription {
-        unsubscribe: () => void;
-    }
-
-    export declare type TrackComponentClickArgs = ComponentClickBuilderArgs & {
+    declare type StatelessExperiencePayload<TPayload> = TPayload & {
         profile?: PartialProfile;
     };
 
-    export declare type TrackComponentHoverArgs = ComponentHoverBuilderArgs & {
+    declare type StatelessInsightsPayload<TPayload> = TPayload & {
+        profile: PartialProfile;
+    };
+
+    declare type StatelessNonStickyTrackViewPayload = Omit<ViewBuilderArgs, 'sticky'> & {
+        profile: PartialProfile;
+        sticky?: false | undefined;
+    };
+
+    declare type StatelessStickyTrackViewPayload = ViewBuilderArgs & {
         profile?: PartialProfile;
+        sticky: true;
     };
 
     /**
-     * Arguments for tracking a component/flag view in stateless mode.
+     * Disposable handle returned by observable subscriptions.
      *
      * @public
+     */
+    export declare interface Subscription {
+        /** Stop receiving future emissions for the subscription. */
+        unsubscribe: () => void;
+    }
+
+    /**
+     * Wrap a signal-like object with an {@link Observable} that suppresses
+     * duplicate emissions according to a comparator.
+     *
+     * @typeParam T - Signal value type.
+     * @param s - Signal-like source exposing a `value` property.
+     * @param isEqual - Comparator that returns `true` when values are equivalent.
+     * @returns Observable adapter that only emits distinct values.
+     *
      * @remarks
-     * The `profile` is optional; when omitted, the APIs may infer identity via
-     * other means.
+     * The first emission is always delivered. Subsequent emissions are skipped
+     * when `isEqual(previous, current)` returns `true`.
+     *
+     * @public
      */
-    export declare type TrackComponentViewArgs = ComponentViewBuilderArgs & {
-        profile?: PartialProfile;
-    };
+    export declare function toDistinctObservable<T>(s: {
+        value: T;
+    }, isEqual: (previous: T, current: T) => boolean): Observable<T>;
+
+    /**
+     * Wrap a signal-like object with the local {@link Observable} contract.
+     *
+     * @typeParam T - Signal value type.
+     * @param s - Signal-like source exposing a `value` property.
+     * @returns Observable adapter for the given signal source.
+     *
+     * @remarks
+     * All emitted values and `current` snapshots are deep-cloned to isolate
+     * subscriber-side mutation from internal Core state.
+     *
+     * @public
+     */
+    export declare function toObservable<T>(s: {
+        value: T;
+    }): Observable<T>;
+
+    export declare const TrackBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        event: z.ZodMiniString<string>;
+        properties: z.ZodMiniOptional<z.ZodMiniPrefault<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniJSONSchema>>>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing track events.
+     *
+     * @public
+     */
+    export declare type TrackBuilderArgs = z.infer<typeof TrackBuilderArgs>;
+
+    export declare const UniversalEventBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments used to construct the universal (shared) portion of all events.
+     *
+     * @public
+     */
+    export declare type UniversalEventBuilderArgs = z.infer<typeof UniversalEventBuilderArgs>;
+
+    export declare const ViewBuilderArgs: z.ZodMiniObject<{
+        campaign: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            medium: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            term: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            content: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        location: z.ZodMiniOptional<z.ZodMiniObject<{
+            coordinates: z.ZodMiniOptional<z.ZodMiniObject<{
+                latitude: z.ZodMiniNumber<number>;
+                longitude: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            city: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            postalCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            region: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            regionCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            country: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            countryCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            continent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            timezone: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            query: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            referrer: z.ZodMiniString<string>;
+            search: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            url: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        screen: z.ZodMiniOptional<z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$catchall<z.ZodMiniJSONSchema>>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        componentId: z.ZodMiniString<string>;
+        experienceId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        variantIndex: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        sticky: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        viewId: z.ZodMiniString<string>;
+        viewDurationMs: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+
+    /**
+     * Arguments for constructing entry view events.
+     *
+     * @public
+     */
+    export declare type ViewBuilderArgs = z.infer<typeof ViewBuilderArgs>;
 
     export { }