@contentful/optimization-core 0.1.0-alpha → 0.1.0-alpha11

package/dist/index.d.ts

@@ -1,15 +1,2523 @@
-export { batch, effect, signals, type Signal, type Signals } from './signals';
-export * from '@contentful/optimization-api-client';
-export * from 'logger';
-export * from './analytics';
-export * from './CoreBase';
-export * from './CoreStateful';
-export * from './CoreStateless';
-export * from './global-constants';
-export * from './lib/decorators';
-export * from './lib/interceptor';
-export * from './lib/value-presence';
-export * from './personalization';
-export { default as CoreStateful } from './CoreStateful';
-export { default as CoreStateless } from './CoreStateless';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * 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 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 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-schemas';
+import type { Flags as Flags_2 } from '@contentful/optimization-api-client/api-schemas';
+import { GlobalApiConfigProperties } 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 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 type { MergeTagEntry } from '@contentful/optimization-api-client/api-schemas';
+import { OptimizationData } from '@contentful/optimization-api-client/api-schemas';
+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 { Profile } from '@contentful/optimization-api-client/api-schemas';
+import { ReadonlySignal } from '@preact/signals-core';
+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 { 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';
+import { ViewEvent } from '@contentful/optimization-api-client/api-schemas';
+import * as z from 'zod/mini';
+
+/**
+ * Anonymous-ID cookie name used by the Optimization Core.
+ *
+ * @public
+ * @remarks
+ * This constant represents the cookie key used by the Optimization Framework
+ * to persist an anonymous identifier for tracking optimization and insights
+ * events when no explicit profile is known.
+ *
+ * @example
+ * ```ts
+ * import { ANONYMOUS_ID_COOKIE } from '@contentful/optimization-core/constants'
+ * const profileId = request.cookies[ANONYMOUS_ID_COOKIE]
+ * ```
+ */
+export declare const ANONYMOUS_ID_COOKIE = "ctfl-opt-aid";
+
+/**
+ * Legacy anoynmous ID cookie key for migration from experience.js
+ *
+ * @internal
+ */
+export declare const ANONYMOUS_ID_COOKIE_LEGACY = "ntaid";
+
+/**
+ * Storage key for the anonymous identifier.
+ *
+ * @internal
+ */
+export declare const ANONYMOUS_ID_KEY = "__ctfl_opt_anonymous_id__";
+
+/**
+ * Legacy anoynmous ID storage key for migration from experience.js
+ *
+ * @internal
+ */
+export declare const ANONYMOUS_ID_KEY_LEGACY = "__nt_anonymous_id__";
+
+export { batch }
+
+/**
+ * Payload emitted when event processing is blocked.
+ *
+ * @public
+ */
+export declare interface BlockedEvent {
+    /** Why the event was blocked. */
+    reason: BlockedEventReason;
+    /** Method name that was blocked. */
+    method: string;
+    /** Original arguments passed to the blocked method call. */
+    args: readonly unknown[];
+}
+
+/**
+ * Most recent blocked-event metadata produced by consent/runtime guards.
+ *
+ * @public
+ */
+declare const blockedEvent: Signal<BlockedEvent | undefined>;
+
+/**
+ * Reasons why an event was blocked before being sent.
+ *
+ * @public
+ */
+export declare type BlockedEventReason = 'consent';
+
+/**
+ * A callback invoked when a method call is blocked by {@link guardedBy}.
+ *
+ * @param methodName - The name of the method that was attempted.
+ * @param args - The readonly array of arguments supplied to the blocked call.
+ * @returns Nothing.
+ *
+ * @public
+ */
+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>;
+
+/**
+ * Storage key for cached Custom Flags.
+ *
+ * @internal
+ */
+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>;
+
+/**
+ * Storage key for the persisted consent status.
+ *
+ * @internal
+ */
+export declare const CONSENT_KEY = "__ctfl_opt_consent__";
+
+/**
+ * Controller for updating the current consent state.
+ *
+ * @internal
+ * @remarks
+ * Intended for internal wiring between Core classes and the consent signal/store.
+ */
+export declare interface ConsentController {
+    /**
+     * Update the runtime consent state.
+     *
+     * @param accept - `true` when the user has granted consent; `false` otherwise.
+     */
+    consent: (accept: boolean) => void;
+}
+
+/**
+ * Contract implemented by classes that gate operations based on consent.
+ *
+ * @internal
+ * @remarks
+ * These methods are consumed by the `@guardedBy` decorator to decide whether to
+ * proceed with an operation and how to report blocked calls.
+ */
+export declare interface ConsentGuard {
+    /**
+     * Determine whether the named operation is permitted given current consent and
+     * any allow‑list configuration.
+     *
+     * @param name - Logical operation/method name (e.g., `'track'`, `'page'`).
+     * @returns `true` if the operation may proceed; otherwise `false`.
+     * @remarks
+     * The mapping between method names and event type strings may be product‑specific.
+     */
+    hasConsent: (name: string) => boolean;
+    /**
+     * Hook invoked when an operation is blocked due to missing consent.
+     *
+     * @param name - The blocked operation/method name.
+     * @param args - The original call arguments, provided for diagnostics/telemetry.
+     * @returns Nothing. Implementations typically log and/or emit diagnostics.
+     */
+    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<TConfig extends CoreConfig = CoreConfig> {
+    /** Shared Optimization API client instance. */
+    readonly api: ApiClient;
+    /** Shared event builder instance. */
+    readonly eventBuilder: EventBuilder;
+    /** 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;
+    /**
+     * Create the core with API client and logging preconfigured.
+     *
+     * @param config - Core configuration including API and builder options.
+     * @example
+     * ```ts
+     * const sdk = new CoreStateless({ clientId: 'abc123', environment: 'prod' })
+     * ```
+     */
+    constructor(config: TConfig, api?: CoreBaseApiClientConfig);
+    /**
+     * Get the value of a custom flag derived from a set of optimization changes.
+     *
+     * @param name - The flag key to resolve.
+     * @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 Core's shared flag resolution.
+     * @example
+     * ```ts
+     * const darkMode = core.getFlag('dark-mode', data.changes)
+     * ```
+     */
+    getFlag(name: string, changes?: ChangeArray): Json;
+    /**
+     * 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 selectedOptimizations - Optional selected optimization array for the current profile.
+     * @returns {@link ResolvedData} containing the resolved entry and
+         *   selected optimization metadata (if any).
+         * @example
+         * ```ts
+         * const { entry, selectedOptimization } = core.resolveOptimizedEntry(
+         *   baselineEntry,
+         *   data.selectedOptimizations,
+         * )
+         * ```
+         */
+     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.
+      * @example
+      * ```ts
+      * const name = core.getMergeTagValue(mergeTagNode, profile)
+      * ```
+      */
+     getMergeTagValue(embeddedEntryNodeTarget: MergeTagEntry, profile?: Profile): string | undefined;
+    }
+
+    declare interface CoreBaseApiClientConfig {
+        experience?: ApiClientConfig['experience'];
+        insights?: ApiClientConfig['insights'];
+    }
+
+    /**
+     * Options for configuring the `CoreBase` runtime and underlying clients.
+     *
+     * @public
+     */
+    export declare interface CoreConfig extends Pick<ApiClientConfig, GlobalApiConfigProperties> {
+        /**
+         * Event builder configuration (channel/library metadata, etc.).
+         */
+        eventBuilder?: EventBuilderConfig;
+        /** Minimum log level for the default console sink. */
+        logLevel?: LogLevels;
+    }
+
+    /**
+     * 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 optimization and insights. */
+        profile?: Profile;
+        /** Initial diff of changes produced by the service. */
+        changes?: ChangeArray;
+        /** Preselected optimization variants (e.g., winning treatments). */
+        selectedOptimizations?: SelectedOptimizationArray;
+    }
+
+    /**
+     * 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.
+     *
+     * @public
+     */
+    export declare class CoreStateful extends CoreStatefulEventEmitter implements ConsentController, ConsentGuard {
+        private readonly singletonOwner;
+        private destroyed;
+        protected readonly allowedEventTypes: EventType[];
+        protected readonly experienceQueue: ExperienceQueue;
+        protected readonly insightsQueue: InsightsQueue;
+        protected readonly onEventBlocked?: CoreStatefulConfig['onEventBlocked'];
+        /**
+         * 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 {
+        /**
+         * Unified API configuration for stateful environments.
+         */
+        api?: CoreStatefulApiConfig;
+        /**
+         * 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.
+         */
+        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;
+        /**
+         * Convenience wrapper for sending an `identify` event through the Experience path.
+         *
+         * @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 through the Experience path.
+         *
+         * @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 through the Experience path.
+         *
+         * @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 through the Experience path.
+         *
+         * @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 an entry view through Insights and, when sticky, Experience.
+         *
+         * @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
+         * await core.trackView({ componentId: 'entry-123', sticky: true })
+         * ```
+         */
+        trackView(payload: ViewBuilderArgs & {
+            profile?: PartialProfile;
+        }): Promise<OptimizationData | undefined>;
+        /**
+         * Track an entry click through Insights.
+         *
+         * @param payload - Entry click builder arguments.
+         * @returns A promise that resolves when processing completes.
+         * @example
+         * ```ts
+         * await core.trackClick({ componentId: 'entry-123' })
+         * ```
+         */
+        trackClick(payload: ClickBuilderArgs): Promise<void>;
+        /**
+         * Track an entry hover through Insights.
+         *
+         * @param payload - Entry hover builder arguments.
+         * @returns A promise that resolves when processing completes.
+         * @example
+         * ```ts
+         * await core.trackHover({ componentId: 'entry-123' })
+         * ```
+         */
+        trackHover(payload: HoverBuilderArgs): Promise<void>;
+        /**
+         * Track a feature flag view through Insights.
+         *
+         * @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' })
+         * ```
+         */
+        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;
+    }
+
+    /**
+     * Core runtime for stateless environments.
+     *
+     * @public
+     * Built on top of `CoreBase`. Request-emitting methods are exposed through
+     * {@link CoreStateless.forRequest}.
+     */
+    export declare class CoreStateless extends CoreBase<CoreStatelessConfig> {
+        constructor(config: CoreStatelessConfig);
+        /**
+         * Bind request-scoped Experience API options for a single stateless request.
+         *
+         * @param options - Request-scoped Experience API options.
+         * @returns A lightweight request scope for stateless event emission.
+         */
+        forRequest(options?: CoreStatelessRequestOptions): CoreStatelessRequestScope;
+    }
+
+    /**
+     * API configuration for stateless Core runtimes.
+     *
+     * @public
+     */
+    export declare interface CoreStatelessApiConfig extends CoreSharedApiConfig {
+    }
+
+    /**
+     * Configuration for stateless Optimization Core runtimes.
+     *
+     * @public
+     * @remarks
+     * This configuration extends {@link CoreConfig} but allows partial overrides
+     * of the event-builder configuration. SDKs commonly inject their own library
+     * metadata or channel definitions.
+     */
+    export declare interface CoreStatelessConfig extends CoreConfig {
+        /**
+         * Unified API configuration for stateless environments.
+         */
+        api?: CoreStatelessApiConfig;
+        /**
+         * Overrides for the event builder configuration. Omits methods that are only
+         * useful in stateful environments.
+         */
+        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'> {
+    }
+
+    /**
+     * Stateless request scope created by {@link CoreStateless.forRequest}.
+     *
+     * @public
+     */
+    export declare class CoreStatelessRequestScope {
+        private readonly core;
+        private readonly options;
+        constructor(core: CoreStateless, options?: CoreStatelessRequestOptions);
+        identify(payload: StatelessExperiencePayload<IdentifyBuilderArgs>): Promise<OptimizationData>;
+        page(payload?: StatelessExperiencePayload<PageViewBuilderArgs>): Promise<OptimizationData>;
+        screen(payload: StatelessExperiencePayload<ScreenViewBuilderArgs>): Promise<OptimizationData>;
+        track(payload: StatelessExperiencePayload<TrackBuilderArgs>): Promise<OptimizationData>;
+        /**
+         * Record an entry view in a stateless runtime.
+         *
+         * @remarks
+         * Non-sticky entry views require `payload.profile.id` for Insights delivery.
+         * Sticky entry views may omit `profile`, because the returned Experience
+         * profile is reused for the paired Insights event.
+         */
+        trackView(payload: StatelessStickyTrackViewPayload | StatelessNonStickyTrackViewPayload): Promise<OptimizationData | undefined>;
+        /**
+         * Record an entry click in a stateless runtime.
+         *
+         * @remarks
+         * Stateless Insights delivery requires `payload.profile.id`.
+         */
+        trackClick(payload: StatelessInsightsPayload<ClickBuilderArgs>): Promise<void>;
+        /**
+         * Record an entry hover in a stateless runtime.
+         *
+         * @remarks
+         * Stateless Insights delivery requires `payload.profile.id`.
+         */
+        trackHover(payload: StatelessInsightsPayload<HoverBuilderArgs>): Promise<void>;
+        /**
+         * Record a Custom Flag view in a stateless runtime.
+         *
+         * @remarks
+         * Stateless Insights delivery requires `payload.profile.id`.
+         */
+        trackFlagView(payload: StatelessInsightsPayload<FlagViewBuilderArgs>): Promise<void>;
+        private sendExperienceEvent;
+        private sendInsightsEvent;
+    }
+
+    /**
+     * Combined observable state exposed by the stateful core.
+     *
+     * @public
+     */
+    export declare interface CoreStates {
+        /** Current consent value (if any). */
+        consent: Observable<boolean | undefined>;
+        /** Whether the preview panel has been attached to the host runtime. */
+        previewPanelAttached: Observable<boolean>;
+        /** Whether the preview panel is currently open in the host runtime. */
+        previewPanelOpen: Observable<boolean>;
+        /** Stream of the most recent blocked event payload. */
+        blockedEventStream: Observable<BlockedEvent | undefined>;
+        /** 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>;
+    }
+
+    /**
+     * Storage key for the debug flag toggle.
+     *
+     * @internal
+     */
+    export declare const DEBUG_FLAG_KEY = "__ctfl_opt_debug__";
+
+    /**
+     * 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
+     */
+    export declare const DEFAULT_PAGE_PROPERTIES: {
+        path: string;
+        query: {};
+        referrer: string;
+        search: string;
+        title: string;
+        url: string;
+    };
+
+    export { effect }
+
+    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
+     */
+    export declare type EntryInteractionBuilderArgsBase = z.infer<typeof EntryInteractionBuilderArgsBase>;
+
+    /**
+     * Most recent emitted optimization event.
+     *
+     * @public
+     */
+    declare const event_2: Signal<InsightsEvent | ExperienceEvent | undefined>;
+
+    /**
+     * Helper class for building optimization events.
+     *
+     * @remarks
+     * This class coordinates configuration and argument validation to produce
+     * strongly-typed event payloads compatible with
+     * `@contentful/optimization-api-schemas`.
+     *
+     * @see {@link EventBuilderConfig}
+     *
+     * @public
+     */
+    export declare class EventBuilder {
+        /**
+         * Application metadata attached to each event.
+         *
+         * @internal
+         */
+        app?: App;
+        /**
+         * Channel value attached to each event.
+         *
+         * @internal
+         */
+        channel: Channel;
+        /**
+         * Library metadata attached to each event.
+         *
+         * @internal
+         */
+        library: Library;
+        /**
+         * Function that provides the locale when available.
+         *
+         * @internal
+         */
+        getLocale: () => string | undefined;
+        /**
+         * Function that provides baseline page properties.
+         *
+         * @internal
+         */
+        getPageProperties: () => Page;
+        /**
+         * Function that provides the user agent string when available.
+         *
+         * @internal
+         */
+        getUserAgent: () => string | undefined;
+        /**
+         * 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.
+         *
+         * @example
+         * ```ts
+         * const builder = new EventBuilder({
+         *   channel: 'web',
+         *   library: { name: '@contentful/optimization-sdk', version: '1.0.0' },
+         * })
+         * ```
+         */
+        constructor(config: EventBuilderConfig);
+        /**
+         * 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.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildView({
+         *   componentId: 'entry-123',
+         *   viewId: crypto.randomUUID(),
+         *   experienceId: 'experience-123',
+         *   variantIndex: 1,
+         *   viewDurationMs: 1_000,
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildView(args: ViewBuilderArgs): ViewEvent;
+        /**
+         * 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.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildClick({
+         *   componentId: 'entry-123',
+         *   experienceId: 'experience-123',
+         *   variantIndex: 1,
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildClick(args: ClickBuilderArgs): ClickEvent;
+        /**
+         * 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.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildHover({
+         *   componentId: 'entry-123',
+         *   hoverId: crypto.randomUUID(),
+         *   experienceId: 'experience-123',
+         *   hoverDurationMs: 1_000,
+         *   variantIndex: 1,
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildHover(args: HoverBuilderArgs): HoverEvent;
+        /**
+         * Builds a `component` view event payload for Custom Flag exposure tracking.
+         *
+         * @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'`.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildFlagView({
+         *   componentId: 'feature-flag-key',
+         *   viewId: crypto.randomUUID(),
+         *   experienceId: 'experience-123',
+         *   viewDurationMs: 1_000,
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildFlagView(args: FlagViewBuilderArgs): ViewEvent;
+        /**
+         * 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.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildIdentify({
+         *   userId: 'user-123',
+         *   traits: { plan: 'pro' },
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildIdentify(args: IdentifyBuilderArgs): IdentifyEvent;
+        /**
+         * Builds a page view event payload.
+         *
+         * @param args - Optional {@link PageViewBuilderArgs} overrides for the page view event.
+         * @returns A {@link PageViewEvent} payload.
+         *
+         * @remarks
+         * 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 event = builder.buildPageView({
+         *   properties: {
+         *     title: 'Homepage',
+         *   },
+         * })
+         * ```
+         *
+         * @public
+         */
+        buildPageView(args?: PageViewBuilderArgs): PageViewEvent;
+        /**
+         * Builds a screen view event payload.
+         *
+         * @param args - {@link ScreenViewBuilderArgs} arguments for the screen view event.
+         * @returns A {@link ScreenViewEvent} payload.
+         *
+         * @example
+         * ```ts
+         * const event = builder.buildScreenView({
+         *   name: 'home',
+         *   properties: {
+         *     title: 'Home Screen',
+         *   },
+         * })
+         * ```
+         *
+         * @public
+         */
+        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;
+    }
+
+    /**
+     * Configuration options for creating an {@link EventBuilder} instance.
+     *
+     * @remarks
+     * The configuration is typically provided by the host application to adapt
+     * event payloads to the runtime environment (browser, framework, etc.).
+     *
+     * @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,
+     *   }),
+     * })
+     * ```
+     *
+     * @public
+     */
+    export declare interface EventBuilderConfig {
+        /**
+         * The application definition used to attribute events to a specific consumer app.
+         *
+         * @remarks
+         * When not provided, events will not contain app metadata in their context.
+         */
+        app?: App;
+        /**
+         * The channel that identifies where events originate from (e.g. web, mobile).
+         *
+         * @see {@link Channel}
+         */
+        channel: Channel;
+        /**
+         * The client library metadata that is attached to all events.
+         *
+         * @remarks
+         * This is typically used to record the library name and version.
+         */
+        library: Library;
+        /**
+         * Function used to resolve the locale for outgoing events.
+         *
+         * @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.
+         *
+         * @returns The locale string (e.g. `'en-US'`), or `undefined` if unavailable.
+         */
+        getLocale?: () => string | undefined;
+        /**
+         * 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.
+         *
+         * @returns A {@link Page} object containing information about the current page.
+         * @see {@link Page}
+         */
+        getPageProperties?: () => Page;
+        /**
+         * Function used to obtain the current user agent string when applicable.
+         *
+         * @returns A user agent string, or `undefined` if unavailable.
+         */
+        getUserAgent?: () => string | undefined;
+    }
+
+    /**
+     * Union of all event type keys that stateful Core may emit.
+     *
+     * @public
+     */
+    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. */
+        droppedEvents: ExperienceEventArray;
+        /** Configured queue max size. */
+        maxEvents: number;
+        /** Queue size after enqueueing the current event. */
+        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'];
+    }
+
+    /**
+     * 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 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_2;
+    };
+
+    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 type FlagViewBuilderArgs = z.infer<typeof FlagViewBuilderArgs>;
+
+    /**
+     * 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 function guardedBy<T extends object>(predicateName: keyof T & (string | symbol), opts?: GuardedByOptions<T>): GuardedByFunction<T>;
+
+    /**
+     * 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 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}.
+     *
+     * @typeParam T - The instance type on which the decorator is applied.
+     *
+     * @public
+     */
+    export declare interface GuardedByOptions<T extends object> {
+        /**
+         * Inverts the predicate result.
+         *
+         * When `true`, a truthy predicate result **blocks** the method.
+         * When `false` (default) or omitted, a truthy predicate result **allows** the method.
+         *
+         * @defaultValue `false`
+         * @remarks
+         * This option is useful when the predicate expresses a *forbid* condition
+         * (e.g. "isLocked" or "isDestroyed") rather than an *allow* condition.
+         */
+        readonly invert?: boolean;
+        /**
+         * Either a function to call when a method is blocked, or the name/symbol of
+         * an instance method on `this` to call when blocked.
+         *
+         * Both forms are **synchronous** and receive `(methodName, argsArray)`.
+         * If omitted, blocked calls fail silently (i.e., return `undefined` or
+         * `Promise<undefined>` for async methods).
+         *
+         * @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.
+         */
+        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> {
+        /**
+         * The registry of interceptors keyed by their insertion id.
+         *
+         * @privateRemarks Internal storage; use {@link add}, {@link remove}, and
+         * {@link clear} to manage contents.
+         * @readonly
+         * @defaultValue `new Map()`
+         */
+        private readonly interceptors;
+        /**
+         * The next numeric id to assign to an added interceptor.
+         *
+         * @privateRemarks Used only to generate unique, monotonically increasing ids.
+         * @defaultValue `0`
+         */
+        private nextId;
+        /**
+         * Add an interceptor and return its identifier.
+         *
+         * @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));
+         * ```
+         * @public
+         */
+        add(interceptor: Interceptor<T>): number;
+        /**
+         * Remove an interceptor by its identifier.
+         *
+         * @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);
+         * ```
+         * @public
+         */
+        remove(id: number): boolean;
+        /**
+         * Remove all registered interceptors.
+         *
+         * @returns Nothing.
+         * @remarks After calling this, {@link count} will return `0`.
+         * @example
+         * ```ts
+         * manager.clear();
+         * ```
+         * @public
+         */
+        clear(): void;
+        /**
+         * Get the number of currently registered interceptors.
+         *
+         * @returns The count of interceptors.
+         * @example
+         * ```ts
+         * if (manager.count() === 0) { /* ... *\/ }
+         * ```
+         * @public
+         */
+        count(): number;
+        /**
+         * Run all interceptors in sequence on an input value and return the final result.
+         *
+         * 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
+         * const result = await manager.run(initial);
+         * ```
+         * @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
+     */
+    export 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: {
+        /**
+         * Generate a list of candidate selectors for a merge-tag ID.
+         *
+         * @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')
+         * ```
+         */
+        normalizeSelectors(id: string): string[];
+        /**
+         * Look up a merge-tag value from a profile using normalized selectors.
+         *
+         * @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 value = MergeTagValueResolver.getValueFromProfile('user_email', profile)
+         * if (value) sendEmailTo(value)
+         * ```
+         */
+        getValueFromProfile(id: string, profile?: Profile): string | undefined;
+        /**
+         * 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 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')
+         * ```
+         */
+        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> {
+        /**
+         * Deep-cloned snapshot of the current signal value.
+         *
+         * @remarks
+         * A clone is returned to prevent accidental in-place mutations from leaking
+         * back into internal signal state.
+         */
+        readonly current: T;
+        /**
+         * Subscribe to all value updates (including the current value immediately).
+         *
+         * @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`.
+         */
+        subscribe: (next: (v: T) => void) => Subscription;
+        /**
+         * Subscribe to the first non-nullish value, then auto-unsubscribe.
+         *
+         * @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`.
+         */
+        subscribeOnce: (next: (v: NonNullable<T>) => void) => Subscription;
+    }
+
+    /**
+     * Runtime online/offline signal used by queue flush logic.
+     *
+     * @defaultValue `true`
+     * @public
+     */
+    declare const online: Signal<boolean | undefined>;
+
+    /**
+     * 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 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 SelectedOptimization} is treated as
+     * 1‑based (index 1 = first variant). A value of `0` indicates baseline.
+     */
+    export declare const OptimizedEntryResolver: {
+        /**
+         * Find the optimization entry corresponding to one of the selected experiences.
+         *
+         * @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 OptimizationEntry}, or `undefined` if not found/invalid.
+         * @remarks
+         * 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 optimizationEntry = OptimizedEntryResolver.getOptimizationEntry({
+         *   optimizedEntry: entry,
+         *   selectedOptimizations
+         * })
+         * ```
+         */
+        getOptimizationEntry({ optimizedEntry, selectedOptimizations, }: {
+            optimizedEntry: OptimizedEntry_2;
+            selectedOptimizations: SelectedOptimizationArray;
+        }, skipValidation?: boolean): OptimizationEntry_2 | undefined;
+        /**
+         * Look up the selection metadata for a specific optimization entry.
+         *
+         * @param params - Object with the target optimization entry and selections.
+         * @param skipValidation - When `true`, skip type checks.
+         * @returns The matching {@link SelectedOptimization}, if present.
+         * @remarks
+         * Selected optimizations are supplied by the Experience API in the
+         * `experiences` response data property.
+         * @example
+         * ```ts
+         * const selectedOptimization = OptimizedEntryResolver.getSelectedOptimization({
+         *   optimizationEntry,
+         *   selectedOptimizations
+         * })
+         * ```
+         */
+        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, 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
+         * optimization configuration component's `variants` array supplied by the
+         * optimized entry via its `nt_config` field.
+         * @example
+         * ```ts
+         * const selectedVariant = OptimizedEntryResolver.getSelectedVariant({
+         *   optimizedEntry: entry,
+         *   optimizationEntry,
+         *   selectedVariantIndex: 2 // second variant (1‑based)
+         * })
+         * ```
+         */
+        getSelectedVariant({ optimizedEntry, optimizationEntry, selectedVariantIndex, }: {
+            optimizedEntry: OptimizedEntry_2;
+            optimizationEntry: OptimizationEntry_2;
+            selectedVariantIndex: number;
+        }, skipValidation?: boolean): EntryReplacementVariant_2 | undefined;
+        /**
+         * Resolve the concrete Contentful entry that corresponds to a selected variant.
+         *
+         * @typeParam S - Entry skeleton type.
+         * @typeParam M - Chain modifiers.
+         * @typeParam L - Locale code.
+         * @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
+         * An optimized entry will resolve either to the baseline (the entry
+         * supplied as `optimizedEntry`) or the selected variant.
+         * @example
+         * ```ts
+         * const selectedVariantEntry = OptimizedEntryResolver.getSelectedVariantEntry<{ fields: unknown }>({
+         *   optimizationEntry,
+         *   selectedVariant
+         * })
+         * ```
+         */
+        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: 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;
+
+    /**
+     * Well-known symbols used by the preview panel bridge.
+     *
+     * @public
+     */
+    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>;
+
+    /**
+     * Symbol-keyed signal bridge shared between core and first-party preview tooling.
+     *
+     * @public
+     */
+    export declare interface PreviewPanelSignalObject {
+        /** Signals instance populated by {@link CoreStateful.registerPreviewPanel}. */
+        [PREVIEW_PANEL_SIGNALS_SYMBOL]?: Signals | null | undefined;
+        /** Signal helper functions populated by {@link CoreStateful.registerPreviewPanel}. */
+        [PREVIEW_PANEL_SIGNAL_FNS_SYMBOL]?: SignalFns | null | undefined;
+    }
+
+    /**
+     * Active profile associated with current runtime state.
+     *
+     * @public
+     */
+    declare const profile: Signal<Profile | undefined>;
+
+    /**
+     * Storage key for cached profile data.
+     *
+     * @internal
+     */
+    export declare const PROFILE_CACHE_KEY = "__ctfl_opt_profile__";
+
+    /**
+     * Context payload emitted when a queue flush fails.
+     *
+     * @public
+     */
+    export declare interface QueueFlushFailureContext {
+        /** Number of consecutive failed flush attempts. */
+        consecutiveFailures: number;
+        /** Number of queued batches at the time of the failed attempt. */
+        queuedBatches: number;
+        /** Number of queued events at the time of the failed attempt. */
+        queuedEvents: number;
+        /** Delay before the next retry attempt is scheduled. */
+        retryDelayMs: number;
+    }
+
+    /**
+     * Policy options for controlling queue flush retry behavior.
+     *
+     * @public
+     */
+    export declare interface QueueFlushPolicy {
+        /**
+         * Periodic flush interval in milliseconds while events remain queued.
+         *
+         * @defaultValue `30000`
+         */
+        flushIntervalMs?: number;
+        /**
+         * Base retry backoff delay in milliseconds.
+         *
+         * @defaultValue `500`
+         */
+        baseBackoffMs?: number;
+        /**
+         * Maximum retry backoff delay in milliseconds.
+         *
+         * @defaultValue `30000`
+         */
+        maxBackoffMs?: number;
+        /**
+         * Jitter ratio applied to retry delay to avoid synchronized retries.
+         *
+         * @remarks
+         * Value is clamped to `[0, 1]`.
+         *
+         * @defaultValue `0.2`
+         */
+        jitterRatio?: number;
+        /**
+         * Consecutive failures threshold before opening the circuit window.
+         *
+         * @defaultValue `8`
+         */
+        maxConsecutiveFailures?: number;
+        /**
+         * Duration in milliseconds to wait before retrying after circuit opens.
+         *
+         * @defaultValue `120000`
+         */
+        circuitOpenMs?: number;
+        /**
+         * Callback invoked after each failed flush attempt.
+         */
+        onFlushFailure?: (context: QueueFlushFailureContext) => void;
+        /**
+         * Callback invoked when the circuit opens after consecutive failures.
+         */
+        onCircuitOpen?: (context: QueueFlushFailureContext) => void;
+        /**
+         * Callback invoked when a flush succeeds after previous failures.
+         */
+        onFlushRecovered?: (context: QueueFlushRecoveredContext) => void;
+    }
+
+    /**
+     * Context payload emitted when a failed queue flush sequence recovers.
+     *
+     * @public
+     */
+    export declare interface QueueFlushRecoveredContext {
+        /** Consecutive failure count that existed immediately before recovery. */
+        consecutiveFailures: number;
+    }
+
+    /**
+     * 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.
+     * @typeParam L - Locale code.
+     * @public
+     */
+    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 optimization metadata, if a non-baseline variant was chosen. */
+        selectedOptimization?: SelectedOptimization_2;
+    }
+
+    /**
+     * Internal normalized shape of queue flush policy values.
+     *
+     * @internal
+     */
+    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;
+        /** Runtime connectivity signal. */
+        online: typeof online;
+        /** Preview panel attachment signal. */
+        previewPanelAttached: typeof previewPanelAttached;
+        /** Preview panel open-state signal. */
+        previewPanelOpen: typeof previewPanelOpen;
+        /** 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 type StatelessExperiencePayload<TPayload> = TPayload & {
+        profile?: PartialProfile;
+    };
+
+    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;
+    };
+
+    /**
+     * 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 first emission is always delivered. Subsequent emissions are skipped
+     * when `isEqual(previous, current)` returns `true`.
+     *
+     * @public
+     */
+    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 { }