@walkeros/core 0.0.0-next-20251219153324

package/dist/index.d.ts

@@ -0,0 +1,2071 @@
+/**
+ * Core collector configuration interface
+ */
+interface Config$6 {
+    /** Whether to run collector automatically */
+    run?: boolean;
+    /** Version for event tagging */
+    tagging: number;
+    /** Static global properties even on a new run */
+    globalsStatic: Properties;
+    /** Static session data even on a new run */
+    sessionStatic: Partial<SessionData>;
+    /** Logger configuration */
+    logger?: Config$3;
+}
+/**
+ * Initialization configuration that extends Config with initial state
+ */
+interface InitConfig extends Partial<Config$6> {
+    /** Initial consent state */
+    consent?: Consent;
+    /** Initial user data */
+    user?: User;
+    /** Initial global properties */
+    globals?: Properties;
+    /** Source configurations */
+    sources?: InitSources;
+    /** Destination configurations */
+    destinations?: InitDestinations;
+    /** Initial custom properties */
+    custom?: Properties;
+}
+interface SessionData extends Properties {
+    isStart: boolean;
+    storage: boolean;
+    id?: string;
+    start?: number;
+    marketing?: true;
+    updated?: number;
+    isNew?: boolean;
+    device?: string;
+    count?: number;
+    runs?: number;
+}
+interface Sources {
+    [id: string]: Instance;
+}
+interface Destinations$1 {
+    [id: string]: Instance$2;
+}
+type CommandType = 'action' | 'config' | 'consent' | 'context' | 'destination' | 'elb' | 'globals' | 'hook' | 'init' | 'link' | 'run' | 'user' | 'walker' | string;
+/**
+ * Context passed to collector.push for source mapping
+ */
+interface PushContext$1 {
+    mapping?: Config$2;
+}
+/**
+ * Push function signature - handles events only
+ */
+interface PushFn$1 {
+    (event: DeepPartialEvent, context?: PushContext$1): Promise<PushResult>;
+}
+/**
+ * Command function signature - handles walker commands only
+ */
+interface CommandFn {
+    (command: 'config', config: Partial<Config$6>): Promise<PushResult>;
+    (command: 'consent', consent: Consent): Promise<PushResult>;
+    <T extends Types$2>(command: 'destination', destination: Init$1<T> | Instance$2<T>, config?: Config$5<T>): Promise<PushResult>;
+    <K extends keyof Functions>(command: 'hook', name: K, hookFn: Functions[K]): Promise<PushResult>;
+    (command: 'on', type: Types$1, rules: SingleOrArray<Options>): Promise<PushResult>;
+    (command: 'user', user: User): Promise<PushResult>;
+    (command: 'run', runState?: {
+        consent?: Consent;
+        user?: User;
+        globals?: Properties;
+        custom?: Properties;
+    }): Promise<PushResult>;
+    (command: string, data?: unknown, options?: unknown): Promise<PushResult>;
+}
+interface Instance$3 {
+    push: PushFn$1;
+    command: CommandFn;
+    allowed: boolean;
+    config: Config$6;
+    consent: Consent;
+    count: number;
+    custom: Properties;
+    sources: Sources;
+    destinations: Destinations$1;
+    globals: Properties;
+    group: string;
+    hooks: Functions;
+    logger: Instance$1;
+    on: OnConfig;
+    queue: Events;
+    round: number;
+    session: undefined | SessionData;
+    timing: number;
+    user: User;
+    version: string;
+}
+
+type collector_CommandFn = CommandFn;
+type collector_CommandType = CommandType;
+type collector_InitConfig = InitConfig;
+type collector_SessionData = SessionData;
+type collector_Sources = Sources;
+declare namespace collector {
+  export type { collector_CommandFn as CommandFn, collector_CommandType as CommandType, Config$6 as Config, Destinations$1 as Destinations, collector_InitConfig as InitConfig, Instance$3 as Instance, PushContext$1 as PushContext, PushFn$1 as PushFn, collector_SessionData as SessionData, collector_Sources as Sources };
+}
+
+interface Contract$1 {
+    version: string;
+    globals: Globals;
+    context: Contexts;
+    entities: Entities$1;
+}
+interface Globals {
+    [name: string]: Global;
+}
+interface Contexts {
+    [name: string]: Context$3;
+}
+interface Entities$1 {
+    [name: string]: Entity$1;
+}
+interface Properties$2 {
+    [name: string]: Property$2;
+}
+interface Global extends Property$2 {
+}
+interface Context$3 extends Property$2 {
+}
+interface Entity$1 {
+    data: Properties$2;
+    actions: Actions;
+}
+interface Actions {
+    [name: string]: Action;
+}
+interface Action {
+    trigger?: Trigger;
+}
+type Trigger = string;
+interface Property$2 {
+    type?: PropertyType$1;
+    required?: boolean;
+    values?: PropertyValues;
+}
+type PropertyType$1 = 'boolean' | 'string' | 'number';
+type PropertyValues = Array<Property>;
+
+type data_Action = Action;
+type data_Actions = Actions;
+type data_Contexts = Contexts;
+type data_Global = Global;
+type data_Globals = Globals;
+type data_PropertyValues = PropertyValues;
+type data_Trigger = Trigger;
+declare namespace data {
+  export type { data_Action as Action, data_Actions as Actions, Context$3 as Context, data_Contexts as Contexts, Contract$1 as Contract, Entities$1 as Entities, Entity$1 as Entity, data_Global as Global, data_Globals as Globals, Properties$2 as Properties, Property$2 as Property, PropertyType$1 as PropertyType, data_PropertyValues as PropertyValues, data_Trigger as Trigger };
+}
+
+/**
+ * Base environment requirements interface for walkerOS destinations
+ *
+ * This defines the core interface that destinations can use to declare
+ * their runtime environment requirements. Platform-specific extensions
+ * should extend this interface.
+ */
+interface BaseEnv$1 {
+    /**
+     * Generic global properties that destinations may require
+     * Platform-specific implementations can extend this interface
+     */
+    [key: string]: unknown;
+}
+/**
+ * Type bundle for destination generics.
+ * Groups Settings, InitSettings, Mapping, and Env into a single type parameter.
+ */
+interface Types$2<S = unknown, M = unknown, E = BaseEnv$1, I = S> {
+    settings: S;
+    initSettings: I;
+    mapping: M;
+    env: E;
+}
+/**
+ * Generic constraint for Types - ensures T has required properties for indexed access
+ */
+type TypesGeneric$1 = {
+    settings: any;
+    initSettings: any;
+    mapping: any;
+    env: any;
+};
+/**
+ * Type extractors for consistent usage with Types bundle
+ */
+type Settings$1<T extends TypesGeneric$1 = Types$2> = T['settings'];
+type InitSettings$1<T extends TypesGeneric$1 = Types$2> = T['initSettings'];
+type Mapping$1<T extends TypesGeneric$1 = Types$2> = T['mapping'];
+type Env$1<T extends TypesGeneric$1 = Types$2> = T['env'];
+/**
+ * Inference helper: Extract Types from Instance
+ */
+type TypesOf$1<I> = I extends Instance$2<infer T> ? T : never;
+interface Instance$2<T extends TypesGeneric$1 = Types$2> {
+    config: Config$5<T>;
+    queue?: Events;
+    dlq?: DLQ;
+    batches?: BatchRegistry<Mapping$1<T>>;
+    type?: string;
+    env?: Env$1<T>;
+    init?: InitFn<T>;
+    push: PushFn<T>;
+    pushBatch?: PushBatchFn<T>;
+    on?: OnFn;
+}
+interface Config$5<T extends TypesGeneric$1 = Types$2> {
+    consent?: Consent;
+    settings?: InitSettings$1<T>;
+    data?: Value | Values;
+    env?: Env$1<T>;
+    id?: string;
+    init?: boolean;
+    loadScript?: boolean;
+    logger?: Config$3;
+    mapping?: Rules<Rule<Mapping$1<T>>>;
+    policy?: Policy$1;
+    queue?: boolean;
+}
+type PartialConfig$1<T extends TypesGeneric$1 = Types$2> = Config$5<Types$2<Partial<Settings$1<T>> | Settings$1<T>, Partial<Mapping$1<T>> | Mapping$1<T>, Env$1<T>>>;
+interface Policy$1 {
+    [key: string]: Value;
+}
+type Code<T extends TypesGeneric$1 = Types$2> = Instance$2<T> | true;
+type Init$1<T extends TypesGeneric$1 = Types$2> = {
+    code: Code<T>;
+    config?: Partial<Config$5<T>>;
+    env?: Partial<Env$1<T>>;
+};
+interface InitDestinations {
+    [key: string]: Init$1<any>;
+}
+interface Destinations {
+    [key: string]: Instance$2;
+}
+interface Context$2<T extends TypesGeneric$1 = Types$2> {
+    collector: Instance$3;
+    config: Config$5<T>;
+    data?: Data$1;
+    env: Env$1<T>;
+    logger: Instance$1;
+}
+interface InitContext<T extends TypesGeneric$1 = Types$2> {
+    collector: Instance$3;
+    config: Config$5<Types$2<Partial<Settings$1<T>>, Mapping$1<T>, Env$1<T>>>;
+    data?: Data$1;
+    env: Env$1<T>;
+    logger: Instance$1;
+}
+interface PushContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
+    mapping?: Rule<Mapping$1<T>>;
+}
+interface PushBatchContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
+    mapping?: Rule<Mapping$1<T>>;
+}
+type InitFn<T extends TypesGeneric$1 = Types$2> = (context: InitContext<T>) => PromiseOrValue<void | false | Config$5<T>>;
+type PushFn<T extends TypesGeneric$1 = Types$2> = (event: Event, context: PushContext<T>) => PromiseOrValue<void>;
+type PushBatchFn<T extends TypesGeneric$1 = Types$2> = (batch: Batch<Mapping$1<T>>, context: PushBatchContext<T>) => void;
+type PushEvent<Mapping = unknown> = {
+    event: Event;
+    mapping?: Rule<Mapping>;
+};
+type PushEvents<Mapping = unknown> = Array<PushEvent<Mapping>>;
+interface Batch<Mapping> {
+    key: string;
+    events: Events;
+    data: Array<Data$1>;
+    mapping?: Rule<Mapping>;
+}
+interface BatchRegistry<Mapping> {
+    [mappingKey: string]: {
+        batched: Batch<Mapping>;
+        batchFn: () => void;
+    };
+}
+type Data$1 = Property | undefined | Array<Property | undefined>;
+type Ref = {
+    id: string;
+    destination: Instance$2;
+};
+type Push$1 = {
+    queue?: Events;
+    error?: unknown;
+};
+type DLQ = Array<[Event, unknown]>;
+type Result$1 = {
+    successful: Array<Ref>;
+    queued: Array<Ref>;
+    failed: Array<Ref>;
+};
+
+type destination_Batch<Mapping> = Batch<Mapping>;
+type destination_BatchRegistry<Mapping> = BatchRegistry<Mapping>;
+type destination_Code<T extends TypesGeneric$1 = Types$2> = Code<T>;
+type destination_DLQ = DLQ;
+type destination_Destinations = Destinations;
+type destination_InitContext<T extends TypesGeneric$1 = Types$2> = InitContext<T>;
+type destination_InitDestinations = InitDestinations;
+type destination_InitFn<T extends TypesGeneric$1 = Types$2> = InitFn<T>;
+type destination_PushBatchContext<T extends TypesGeneric$1 = Types$2> = PushBatchContext<T>;
+type destination_PushBatchFn<T extends TypesGeneric$1 = Types$2> = PushBatchFn<T>;
+type destination_PushContext<T extends TypesGeneric$1 = Types$2> = PushContext<T>;
+type destination_PushEvent<Mapping = unknown> = PushEvent<Mapping>;
+type destination_PushEvents<Mapping = unknown> = PushEvents<Mapping>;
+type destination_PushFn<T extends TypesGeneric$1 = Types$2> = PushFn<T>;
+type destination_Ref = Ref;
+declare namespace destination {
+  export type { BaseEnv$1 as BaseEnv, destination_Batch as Batch, destination_BatchRegistry as BatchRegistry, destination_Code as Code, Config$5 as Config, Context$2 as Context, destination_DLQ as DLQ, Data$1 as Data, destination_Destinations as Destinations, Env$1 as Env, Init$1 as Init, destination_InitContext as InitContext, destination_InitDestinations as InitDestinations, destination_InitFn as InitFn, InitSettings$1 as InitSettings, Instance$2 as Instance, Mapping$1 as Mapping, PartialConfig$1 as PartialConfig, Policy$1 as Policy, Push$1 as Push, destination_PushBatchContext as PushBatchContext, destination_PushBatchFn as PushBatchFn, destination_PushContext as PushContext, destination_PushEvent as PushEvent, destination_PushEvents as PushEvents, destination_PushFn as PushFn, destination_Ref as Ref, Result$1 as Result, Settings$1 as Settings, Types$2 as Types, TypesGeneric$1 as TypesGeneric, TypesOf$1 as TypesOf };
+}
+
+interface EventFn<R = Promise<PushResult>> {
+    (partialEvent: DeepPartialEvent): R;
+    (event: string): R;
+    (event: string, data: Properties): R;
+}
+interface Fn$1<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
+}
+interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
+    (event: 'walker config', config: Partial<Config>): R;
+    (event: 'walker consent', consent: Consent): R;
+    <T extends Types$2>(event: 'walker destination', destination: Init$1<T> | Instance$2<T>, config?: Config$5<T>): R;
+    <K extends keyof Functions>(event: 'walker hook', name: K, hookFn: Functions[K]): R;
+    (event: 'walker on', type: Types$1, rules: SingleOrArray<Options>): R;
+    (event: 'walker user', user: User): R;
+    (event: 'walker run', runState: {
+        consent?: Consent;
+        user?: User;
+        globals?: Properties;
+        custom?: Properties;
+    }): R;
+}
+type Event$1<R = Promise<PushResult>> = (partialEvent: DeepPartialEvent) => R;
+type PushData<Config = unknown> = DeepPartial<Config> | Consent | User | Properties;
+interface PushResult extends Result$1 {
+    event?: Event;
+    ok: boolean;
+}
+type Layer = Array<IArguments | DeepPartialEvent | unknown[]>;
+
+type elb_EventFn<R = Promise<PushResult>> = EventFn<R>;
+type elb_Layer = Layer;
+type elb_PushData<Config = unknown> = PushData<Config>;
+type elb_PushResult = PushResult;
+type elb_WalkerCommands<R = Promise<PushResult>, Config = unknown> = WalkerCommands<R, Config>;
+declare namespace elb {
+  export type { Event$1 as Event, elb_EventFn as EventFn, Fn$1 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_WalkerCommands as WalkerCommands };
+}
+
+/**
+ * Flow Configuration System
+ *
+ * Core types for walkerOS unified configuration.
+ * Platform-agnostic, runtime-focused.
+ *
+ * The Flow system enables "one config to rule them all" - a single
+ * walkeros.config.json file that manages multiple flows
+ * (web_prod, web_stage, server_prod, etc.) with shared configuration,
+ * variables, and reusable definitions.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Primitive value types for variables
+ */
+type Primitive = string | number | boolean;
+/**
+ * Variables record type for interpolation.
+ * Used at Setup, Config, Source, and Destination levels.
+ */
+type Variables = Record<string, Primitive>;
+/**
+ * Definitions record type for reusable configurations.
+ * Used at Setup, Config, Source, and Destination levels.
+ */
+type Definitions = Record<string, unknown>;
+/**
+ * Packages configuration for build.
+ */
+type Packages = Record<string, {
+    version?: string;
+    imports?: string[];
+    path?: string;
+}>;
+/**
+ * Web platform configuration.
+ *
+ * @remarks
+ * Presence of this key indicates web platform (browser-based tracking).
+ * Builds to IIFE format, ES2020 target, browser platform.
+ */
+interface Web {
+    /**
+     * Window property name for collector instance.
+     * @default "collector"
+     */
+    windowCollector?: string;
+    /**
+     * Window property name for elb function.
+     * @default "elb"
+     */
+    windowElb?: string;
+}
+/**
+ * Server platform configuration.
+ *
+ * @remarks
+ * Presence of this key indicates server platform (Node.js).
+ * Builds to ESM format, Node18 target, node platform.
+ * Reserved for future server-specific options.
+ */
+interface Server {
+}
+/**
+ * Complete multi-flow configuration.
+ * Root type for walkeros.config.json files.
+ *
+ * @remarks
+ * If only one flow exists, it's auto-selected without --flow flag.
+ * Convention: use "default" as the flow name for single-flow configs.
+ *
+ * @example
+ * ```json
+ * {
+ *   "version": 1,
+ *   "$schema": "https://walkeros.io/schema/flow/v1.json",
+ *   "variables": { "CURRENCY": "USD" },
+ *   "flows": {
+ *     "default": { "web": {}, ... }
+ *   }
+ * }
+ * ```
+ */
+interface Setup {
+    /**
+     * Configuration schema version.
+     */
+    version: 1;
+    /**
+     * JSON Schema reference for IDE validation.
+     * @example "https://walkeros.io/schema/flow/v1.json"
+     */
+    $schema?: string;
+    /**
+     * Folders to include in the bundle output.
+     * These folders are copied to dist/ during bundle, making them available
+     * at runtime for both local and Docker execution.
+     *
+     * @remarks
+     * Use for credential files, configuration, or other runtime assets.
+     * Paths are relative to the config file location.
+     * Default: `["./shared"]` if the folder exists, otherwise `[]`.
+     *
+     * @example
+     * ```json
+     * {
+     *   "include": ["./credentials", "./config"]
+     * }
+     * ```
+     */
+    include?: string[];
+    /**
+     * Shared variables for interpolation.
+     * Resolution: process.env > Config.variables > Setup.variables > inline default
+     * Syntax: ${VAR_NAME} or ${VAR_NAME:default}
+     */
+    variables?: Variables;
+    /**
+     * Reusable configuration definitions.
+     * Referenced via JSON Schema $ref syntax: { "$ref": "#/definitions/name" }
+     */
+    definitions?: Definitions;
+    /**
+     * Named flow configurations.
+     * If only one flow exists, it's auto-selected.
+     */
+    flows: Record<string, Config$4>;
+}
+/**
+ * Single flow configuration.
+ * Represents one deployment target (e.g., web_prod, server_stage).
+ *
+ * @remarks
+ * Platform is determined by presence of `web` or `server` key.
+ * Exactly one must be present.
+ *
+ * Variables/definitions cascade: source/destination > config > setup
+ */
+interface Config$4 {
+    /**
+     * Web platform configuration.
+     * Presence indicates web platform (browser-based tracking).
+     * Mutually exclusive with `server`.
+     */
+    web?: Web;
+    /**
+     * Server platform configuration.
+     * Presence indicates server platform (Node.js).
+     * Mutually exclusive with `web`.
+     */
+    server?: Server;
+    /**
+     * Source configurations (data capture).
+     *
+     * @remarks
+     * Sources capture events from various origins:
+     * - Browser DOM interactions (clicks, page views)
+     * - DataLayer pushes
+     * - HTTP requests (server-side)
+     * - Cloud function triggers
+     *
+     * Key = unique source identifier (arbitrary)
+     * Value = source reference with package and config
+     *
+     * @example
+     * ```json
+     * {
+     *   "sources": {
+     *     "browser": {
+     *       "package": "@walkeros/web-source-browser",
+     *       "config": {
+     *         "settings": {
+     *           "pageview": true,
+     *           "session": true
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    sources?: Record<string, SourceReference>;
+    /**
+     * Destination configurations (data output).
+     *
+     * @remarks
+     * Destinations send processed events to external services:
+     * - Google Analytics (gtag)
+     * - Meta Pixel (fbq)
+     * - Custom APIs
+     * - Data warehouses
+     *
+     * Key = unique destination identifier (arbitrary)
+     * Value = destination reference with package and config
+     *
+     * @example
+     * ```json
+     * {
+     *   "destinations": {
+     *     "gtag": {
+     *       "package": "@walkeros/web-destination-gtag",
+     *       "config": {
+     *         "settings": {
+     *           "ga4": { "measurementId": "G-XXXXXXXXXX" }
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    destinations?: Record<string, DestinationReference>;
+    /**
+     * Collector configuration (event processing).
+     *
+     * @remarks
+     * The collector is the central event processing engine.
+     * Configuration includes:
+     * - Consent management
+     * - Global properties
+     * - User identification
+     * - Processing rules
+     *
+     * @see {@link Collector.InitConfig} for complete options
+     *
+     * @example
+     * ```json
+     * {
+     *   "collector": {
+     *     "run": true,
+     *     "tagging": 1,
+     *     "consent": {
+     *       "functional": true,
+     *       "marketing": false
+     *     },
+     *     "globals": {
+     *       "currency": "USD",
+     *       "environment": "production"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    collector?: InitConfig;
+    /**
+     * NPM packages to bundle.
+     */
+    packages?: Packages;
+    /**
+     * Flow-level variables.
+     * Override Setup.variables, overridden by source/destination variables.
+     */
+    variables?: Variables;
+    /**
+     * Flow-level definitions.
+     * Extend Setup.definitions, overridden by source/destination definitions.
+     */
+    definitions?: Definitions;
+}
+/**
+ * Source reference with inline package syntax.
+ *
+ * @remarks
+ * References a source package and provides configuration.
+ * The package is automatically downloaded and imported during build.
+ */
+interface SourceReference {
+    /**
+     * Package specifier with optional version.
+     *
+     * @remarks
+     * Formats:
+     * - `"@walkeros/web-source-browser"` - Latest version
+     * - `"@walkeros/web-source-browser@2.0.0"` - Specific version
+     * - `"@walkeros/web-source-browser@^2.0.0"` - Semver range
+     *
+     * The CLI will:
+     * 1. Parse the package reference
+     * 2. Download from npm
+     * 3. Auto-detect default or named export
+     * 4. Generate import statement
+     *
+     * @example
+     * "package": "@walkeros/web-source-browser@latest"
+     */
+    package: string;
+    /**
+     * Resolved import variable name.
+     *
+     * @remarks
+     * Auto-resolved from packages[package].imports[0] during getFlowConfig().
+     * Can also be provided explicitly for advanced use cases.
+     */
+    code?: string;
+    /**
+     * Source-specific configuration.
+     *
+     * @remarks
+     * Structure depends on the source package.
+     * Passed to the source's initialization function.
+     *
+     * @example
+     * ```json
+     * {
+     *   "config": {
+     *     "settings": {
+     *       "pageview": true,
+     *       "session": true,
+     *       "elb": "elb",
+     *       "prefix": "data-elb"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    config?: unknown;
+    /**
+     * Source environment configuration.
+     *
+     * @remarks
+     * Environment-specific settings for the source.
+     * Merged with default source environment.
+     */
+    env?: unknown;
+    /**
+     * Mark as primary source (provides main ELB).
+     *
+     * @remarks
+     * The primary source's ELB function is returned by `startFlow()`.
+     * Only one source should be marked as primary per flow.
+     *
+     * @default false
+     */
+    primary?: boolean;
+    /**
+     * Source-level variables (highest priority in cascade).
+     * Overrides flow and setup variables.
+     */
+    variables?: Variables;
+    /**
+     * Source-level definitions (highest priority in cascade).
+     * Overrides flow and setup definitions.
+     */
+    definitions?: Definitions;
+}
+/**
+ * Destination reference with inline package syntax.
+ *
+ * @remarks
+ * References a destination package and provides configuration.
+ * Structure mirrors SourceReference for consistency.
+ */
+interface DestinationReference {
+    /**
+     * Package specifier with optional version.
+     *
+     * @remarks
+     * Same format as SourceReference.package
+     *
+     * @example
+     * "package": "@walkeros/web-destination-gtag@2.0.0"
+     */
+    package: string;
+    /**
+     * Resolved import variable name.
+     *
+     * @remarks
+     * Auto-resolved from packages[package].imports[0] during getFlowConfig().
+     * Can also be provided explicitly for advanced use cases.
+     */
+    code?: string;
+    /**
+     * Destination-specific configuration.
+     *
+     * @remarks
+     * Structure depends on the destination package.
+     * Typically includes:
+     * - settings: API keys, IDs, endpoints
+     * - mapping: Event transformation rules
+     * - consent: Required consent states
+     * - policy: Processing rules
+     *
+     * @example
+     * ```json
+     * {
+     *   "config": {
+     *     "settings": {
+     *       "ga4": {
+     *         "measurementId": "G-XXXXXXXXXX"
+     *       }
+     *     },
+     *     "mapping": {
+     *       "page": {
+     *         "view": {
+     *           "name": "page_view",
+     *           "data": { ... }
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    config?: unknown;
+    /**
+     * Destination environment configuration.
+     *
+     * @remarks
+     * Environment-specific settings for the destination.
+     * Merged with default destination environment.
+     */
+    env?: unknown;
+    /**
+     * Destination-level variables (highest priority in cascade).
+     * Overrides flow and setup variables.
+     */
+    variables?: Variables;
+    /**
+     * Destination-level definitions (highest priority in cascade).
+     * Overrides flow and setup definitions.
+     */
+    definitions?: Definitions;
+}
+
+type flow_Definitions = Definitions;
+type flow_DestinationReference = DestinationReference;
+type flow_Packages = Packages;
+type flow_Primitive = Primitive;
+type flow_Server = Server;
+type flow_Setup = Setup;
+type flow_SourceReference = SourceReference;
+type flow_Variables = Variables;
+type flow_Web = Web;
+declare namespace flow {
+  export type { Config$4 as Config, flow_Definitions as Definitions, flow_DestinationReference as DestinationReference, flow_Packages as Packages, flow_Primitive as Primitive, flow_Server as Server, flow_Setup as Setup, flow_SourceReference as SourceReference, flow_Variables as Variables, flow_Web as Web };
+}
+
+type AnyFunction$1<P extends unknown[] = never[], R = unknown> = (...args: P) => R;
+type Functions = {
+    [key: string]: AnyFunction$1;
+};
+interface Parameter<P extends unknown[], R> {
+    fn: (...args: P) => R;
+    result?: R;
+}
+type HookFn<T extends AnyFunction$1> = (params: Parameter<Parameters<T>, ReturnType<T>>, ...args: Parameters<T>) => ReturnType<T>;
+
+type hooks_Functions = Functions;
+type hooks_HookFn<T extends AnyFunction$1> = HookFn<T>;
+declare namespace hooks {
+  export type { AnyFunction$1 as AnyFunction, hooks_Functions as Functions, hooks_HookFn as HookFn };
+}
+
+/**
+ * Log levels from most to least severe
+ */
+declare enum Level {
+    ERROR = 0,
+    INFO = 1,
+    DEBUG = 2
+}
+/**
+ * Normalized error context extracted from Error objects
+ */
+interface ErrorContext {
+    message: string;
+    name: string;
+    stack?: string;
+    cause?: unknown;
+}
+/**
+ * Context passed to log handlers
+ * If an Error was passed, it's normalized into the error property
+ */
+interface LogContext {
+    [key: string]: unknown;
+    error?: ErrorContext;
+}
+/**
+ * Log message function signature
+ * Accepts string or Error as message, with optional context
+ */
+type LogFn = (message: string | Error, context?: unknown | Error) => void;
+/**
+ * Throw function signature - logs error then throws
+ * Returns never as it always throws
+ */
+type ThrowFn = (message: string | Error, context?: unknown) => never;
+/**
+ * Default handler function (passed to custom handlers for chaining)
+ */
+type DefaultHandler = (level: Level, message: string, context: LogContext, scope: string[]) => void;
+/**
+ * Custom log handler function
+ * Receives originalHandler to allow middleware-style chaining
+ */
+type Handler = (level: Level, message: string, context: LogContext, scope: string[], originalHandler: DefaultHandler) => void;
+/**
+ * Logger instance with scoping support
+ * All logs automatically include trace path from scoping
+ */
+interface Instance$1 {
+    /**
+     * Log an error message (always visible unless silenced)
+     */
+    error: LogFn;
+    /**
+     * Log an informational message
+     */
+    info: LogFn;
+    /**
+     * Log a debug message
+     */
+    debug: LogFn;
+    /**
+     * Log an error message and throw an Error
+     * Combines logging and throwing in one call
+     */
+    throw: ThrowFn;
+    /**
+     * Create a scoped child logger with automatic trace path
+     * @param name - Scope name (e.g., destination type, destination key)
+     * @returns A new logger instance with the scope applied
+     */
+    scope: (name: string) => Instance$1;
+}
+/**
+ * Logger configuration options
+ */
+interface Config$3 {
+    /**
+     * Minimum log level to display
+     * @default Level.ERROR
+     */
+    level?: Level | keyof typeof Level;
+    /**
+     * Custom log handler function
+     * Receives originalHandler to preserve default behavior
+     */
+    handler?: Handler;
+}
+/**
+ * Internal config with resolved values and scope
+ */
+interface InternalConfig {
+    level: Level;
+    handler?: Handler;
+    scope: string[];
+}
+/**
+ * Logger factory function type
+ */
+type Factory = (config?: Config$3) => Instance$1;
+
+type logger_DefaultHandler = DefaultHandler;
+type logger_ErrorContext = ErrorContext;
+type logger_Factory = Factory;
+type logger_Handler = Handler;
+type logger_InternalConfig = InternalConfig;
+type logger_Level = Level;
+declare const logger_Level: typeof Level;
+type logger_LogContext = LogContext;
+type logger_LogFn = LogFn;
+type logger_ThrowFn = ThrowFn;
+declare namespace logger {
+  export { type Config$3 as Config, type logger_DefaultHandler as DefaultHandler, type logger_ErrorContext as ErrorContext, type logger_Factory as Factory, type logger_Handler as Handler, type Instance$1 as Instance, type logger_InternalConfig as InternalConfig, logger_Level as Level, type logger_LogContext as LogContext, type logger_LogFn as LogFn, type logger_ThrowFn as ThrowFn };
+}
+
+/**
+ * Shared mapping configuration interface.
+ * Used by both Source.Config and Destination.Config.
+ */
+interface Config$2<T = unknown> {
+    consent?: Consent;
+    data?: Value | Values;
+    mapping?: Rules<Rule<T>>;
+    policy?: Policy;
+}
+interface Policy {
+    [key: string]: Value;
+}
+interface Rules<T = Rule> {
+    [entity: string]: Record<string, T | Array<T>> | undefined;
+}
+interface Rule<Settings = unknown> {
+    batch?: number;
+    batchFn?: (destination: Instance$2, collector: Instance$3) => void;
+    batched?: Batch<Settings>;
+    condition?: Condition;
+    consent?: Consent;
+    settings?: Settings;
+    data?: Data;
+    ignore?: boolean;
+    name?: string;
+    policy?: Policy;
+}
+interface Result {
+    eventMapping?: Rule;
+    mappingKey?: string;
+}
+type Data = Value | Values;
+type Value = ValueType | Array<ValueType>;
+type Values = Array<Value>;
+type ValueType = string | ValueConfig;
+interface ValueConfig {
+    condition?: Condition;
+    consent?: Consent;
+    fn?: Fn;
+    key?: string;
+    loop?: Loop;
+    map?: Map;
+    set?: Value[];
+    validate?: Validate;
+    value?: PropertyType;
+}
+type Condition = (value: DeepPartialEvent | unknown, mapping?: Value, collector?: Instance$3) => PromiseOrValue<boolean>;
+type Fn = (value: DeepPartialEvent | unknown, mapping: Value, options: Options$1) => PromiseOrValue<Property | unknown>;
+type Loop = [Value, Value];
+type Map = {
+    [key: string]: Value;
+};
+interface Options$1 {
+    consent?: Consent;
+    collector?: Instance$3;
+    props?: unknown;
+}
+type Validate = (value?: unknown) => PromiseOrValue<boolean>;
+
+type mapping_Condition = Condition;
+type mapping_Data = Data;
+type mapping_Fn = Fn;
+type mapping_Loop = Loop;
+type mapping_Map = Map;
+type mapping_Policy = Policy;
+type mapping_Result = Result;
+type mapping_Rule<Settings = unknown> = Rule<Settings>;
+type mapping_Rules<T = Rule> = Rules<T>;
+type mapping_Validate = Validate;
+type mapping_Value = Value;
+type mapping_ValueConfig = ValueConfig;
+type mapping_ValueType = ValueType;
+type mapping_Values = Values;
+declare namespace mapping {
+  export type { mapping_Condition as Condition, Config$2 as Config, mapping_Data as Data, mapping_Fn as Fn, mapping_Loop as Loop, mapping_Map as Map, Options$1 as Options, mapping_Policy as Policy, mapping_Result as Result, mapping_Rule as Rule, mapping_Rules as Rules, mapping_Validate as Validate, mapping_Value as Value, mapping_ValueConfig as ValueConfig, mapping_ValueType as ValueType, mapping_Values as Values };
+}
+
+type Config$1 = {
+    consent?: Array<ConsentConfig>;
+    ready?: Array<ReadyConfig>;
+    run?: Array<RunConfig>;
+    session?: Array<SessionConfig>;
+};
+type Types$1 = keyof Config$1;
+interface EventContextMap {
+    consent: Consent;
+    session: SessionData;
+    ready: undefined;
+    run: undefined;
+}
+type EventContext<T extends Types$1> = EventContextMap[T];
+type AnyEventContext = EventContextMap[keyof EventContextMap];
+interface Context$1 {
+    consent?: Consent;
+    session?: unknown;
+}
+type Options = ConsentConfig | ReadyConfig | RunConfig | SessionConfig;
+interface ConsentConfig {
+    [key: string]: ConsentFn;
+}
+type ConsentFn = (collector: Instance$3, consent: Consent) => void;
+type ReadyConfig = ReadyFn;
+type ReadyFn = (collector: Instance$3) => void;
+type RunConfig = RunFn;
+type RunFn = (collector: Instance$3) => void;
+type SessionConfig = SessionFn;
+type SessionFn = (collector: Instance$3, session?: unknown) => void;
+interface OnConfig {
+    consent?: ConsentConfig[];
+    ready?: ReadyConfig[];
+    run?: RunConfig[];
+    session?: SessionConfig[];
+    [key: string]: ConsentConfig[] | ReadyConfig[] | RunConfig[] | SessionConfig[] | undefined;
+}
+type OnFn<T extends TypesGeneric$1 = Types$2> = (type: Types$1, context: Context$2<T>) => PromiseOrValue<void>;
+type OnFnRuntime = (type: Types$1, context: Context$2) => PromiseOrValue<void>;
+
+type on_AnyEventContext = AnyEventContext;
+type on_ConsentConfig = ConsentConfig;
+type on_ConsentFn = ConsentFn;
+type on_EventContext<T extends Types$1> = EventContext<T>;
+type on_EventContextMap = EventContextMap;
+type on_OnConfig = OnConfig;
+type on_OnFn<T extends TypesGeneric$1 = Types$2> = OnFn<T>;
+type on_OnFnRuntime = OnFnRuntime;
+type on_Options = Options;
+type on_ReadyConfig = ReadyConfig;
+type on_ReadyFn = ReadyFn;
+type on_RunConfig = RunConfig;
+type on_RunFn = RunFn;
+type on_SessionConfig = SessionConfig;
+type on_SessionFn = SessionFn;
+declare namespace on {
+  export type { on_AnyEventContext as AnyEventContext, Config$1 as Config, on_ConsentConfig as ConsentConfig, on_ConsentFn as ConsentFn, Context$1 as Context, on_EventContext as EventContext, on_EventContextMap as EventContextMap, on_OnConfig as OnConfig, on_OnFn as OnFn, on_OnFnRuntime as OnFnRuntime, on_Options as Options, on_ReadyConfig as ReadyConfig, on_ReadyFn as ReadyFn, on_RunConfig as RunConfig, on_RunFn as RunFn, on_SessionConfig as SessionConfig, on_SessionFn as SessionFn, Types$1 as Types };
+}
+
+interface Context {
+    city?: string;
+    country?: string;
+    encoding?: string;
+    hash?: string;
+    ip?: string;
+    language?: string;
+    origin?: string;
+    region?: string;
+    userAgent?: string;
+    [key: string]: string | undefined;
+}
+
+type request_Context = Context;
+declare namespace request {
+  export type { request_Context as Context };
+}
+
+type Contracts = Array<Contract>;
+type Contract = {
+    [entity: string]: {
+        [action: string]: Properties$1;
+    };
+};
+type Properties$1 = {
+    [key: string]: Property$1 | undefined;
+};
+type Property$1 = {
+    allowedKeys?: string[];
+    allowedValues?: unknown[];
+    maxLength?: number;
+    max?: number;
+    min?: number;
+    required?: boolean;
+    schema?: Properties$1;
+    strict?: boolean;
+    type?: string;
+    validate?: (value: unknown, key: string, event: AnyObject) => Property;
+};
+
+type schema_Contract = Contract;
+type schema_Contracts = Contracts;
+declare namespace schema {
+  export type { schema_Contract as Contract, schema_Contracts as Contracts, Properties$1 as Properties, Property$1 as Property };
+}
+
+/**
+ * Base Env interface for dependency injection into sources.
+ *
+ * Sources receive all their dependencies through this environment object,
+ * making them platform-agnostic and easily testable.
+ */
+interface BaseEnv {
+    [key: string]: unknown;
+    push: PushFn$1;
+    command: CommandFn;
+    sources?: Sources;
+    elb: Fn$1;
+    logger: Instance$1;
+}
+/**
+ * Type bundle for source generics.
+ * Groups Settings, Mapping, Push, Env, and InitSettings into a single type parameter.
+ *
+ * @template S - Settings configuration type
+ * @template M - Mapping configuration type
+ * @template P - Push function signature (flexible to support HTTP handlers, etc.)
+ * @template E - Environment dependencies type
+ * @template I - InitSettings configuration type (user input)
+ */
+interface Types<S = unknown, M = unknown, P = Fn$1, E = BaseEnv, I = S> {
+    settings: S;
+    initSettings: I;
+    mapping: M;
+    push: P;
+    env: E;
+}
+/**
+ * Generic constraint for Types - ensures T has required properties for indexed access
+ */
+type TypesGeneric = {
+    settings: any;
+    initSettings: any;
+    mapping: any;
+    push: any;
+    env: any;
+};
+/**
+ * Type extractors for consistent usage with Types bundle
+ */
+type Settings<T extends TypesGeneric = Types> = T['settings'];
+type InitSettings<T extends TypesGeneric = Types> = T['initSettings'];
+type Mapping<T extends TypesGeneric = Types> = T['mapping'];
+type Push<T extends TypesGeneric = Types> = T['push'];
+type Env<T extends TypesGeneric = Types> = T['env'];
+/**
+ * Inference helper: Extract Types from Instance
+ */
+type TypesOf<I> = I extends Instance<infer T> ? T : never;
+interface Config<T extends TypesGeneric = Types> extends Config$2<Mapping<T>> {
+    settings?: InitSettings<T>;
+    env?: Env<T>;
+    id?: string;
+    logger?: Config$3;
+    disabled?: boolean;
+    primary?: boolean;
+}
+type PartialConfig<T extends TypesGeneric = Types> = Config<Types<Partial<Settings<T>> | Settings<T>, Partial<Mapping<T>> | Mapping<T>, Push<T>, Env<T>>>;
+interface Instance<T extends TypesGeneric = Types> {
+    type: string;
+    config: Config<T>;
+    push: Push<T>;
+    destroy?(): void | Promise<void>;
+    on?(event: Types$1, context?: unknown): void | Promise<void>;
+}
+type Init<T extends TypesGeneric = Types> = (config: Partial<Config<T>>, env: Env<T>) => Instance<T> | Promise<Instance<T>>;
+type InitSource<T extends TypesGeneric = Types> = {
+    code: Init<T>;
+    config?: Partial<Config<T>>;
+    env?: Partial<Env<T>>;
+    primary?: boolean;
+};
+/**
+ * Sources configuration for collector.
+ * Maps source IDs to their initialization configurations.
+ */
+interface InitSources {
+    [sourceId: string]: InitSource<any>;
+}
+
+type source_BaseEnv = BaseEnv;
+type source_Config<T extends TypesGeneric = Types> = Config<T>;
+type source_Env<T extends TypesGeneric = Types> = Env<T>;
+type source_Init<T extends TypesGeneric = Types> = Init<T>;
+type source_InitSettings<T extends TypesGeneric = Types> = InitSettings<T>;
+type source_InitSource<T extends TypesGeneric = Types> = InitSource<T>;
+type source_InitSources = InitSources;
+type source_Instance<T extends TypesGeneric = Types> = Instance<T>;
+type source_Mapping<T extends TypesGeneric = Types> = Mapping<T>;
+type source_PartialConfig<T extends TypesGeneric = Types> = PartialConfig<T>;
+type source_Push<T extends TypesGeneric = Types> = Push<T>;
+type source_Settings<T extends TypesGeneric = Types> = Settings<T>;
+type source_Types<S = unknown, M = unknown, P = Fn$1, E = BaseEnv, I = S> = Types<S, M, P, E, I>;
+type source_TypesGeneric = TypesGeneric;
+type source_TypesOf<I> = TypesOf<I>;
+declare namespace source {
+  export type { source_BaseEnv as BaseEnv, source_Config as Config, source_Env as Env, source_Init as Init, source_InitSettings as InitSettings, source_InitSource as InitSource, source_InitSources as InitSources, source_Instance as Instance, source_Mapping as Mapping, source_PartialConfig as PartialConfig, source_Push as Push, source_Settings as Settings, source_Types as Types, source_TypesGeneric as TypesGeneric, source_TypesOf as TypesOf };
+}
+
+type AnyObject<T = unknown> = Record<string, T>;
+type Elb = Fn$1;
+type AnyFunction = (...args: unknown[]) => unknown;
+type SingleOrArray<T> = T | Array<T>;
+type Events = Array<Event>;
+type PartialEvent = Partial<Event>;
+type DeepPartialEvent = DeepPartial<Event>;
+interface Event {
+    name: string;
+    data: Properties;
+    context: OrderedProperties;
+    globals: Properties;
+    custom: Properties;
+    user: User;
+    nested: Entities;
+    consent: Consent;
+    id: string;
+    trigger: string;
+    entity: string;
+    action: string;
+    timestamp: number;
+    timing: number;
+    group: string;
+    count: number;
+    version: Version;
+    source: Source;
+}
+interface Consent {
+    [name: string]: boolean;
+}
+interface User extends Properties {
+    id?: string;
+    device?: string;
+    session?: string;
+    hash?: string;
+    address?: string;
+    email?: string;
+    phone?: string;
+    userAgent?: string;
+    browser?: string;
+    browserVersion?: string;
+    deviceType?: string;
+    language?: string;
+    country?: string;
+    region?: string;
+    city?: string;
+    zip?: string;
+    timezone?: string;
+    os?: string;
+    osVersion?: string;
+    screenSize?: string;
+    ip?: string;
+    internal?: boolean;
+}
+interface Version extends Properties {
+    source: string;
+    tagging: number;
+}
+interface Source extends Properties {
+    type: SourceType;
+    id: string;
+    previous_id: string;
+}
+type SourceType = 'web' | 'server' | 'app' | 'other' | string;
+type PropertyType = boolean | string | number | {
+    [key: string]: Property;
+};
+type Property = PropertyType | Array<PropertyType>;
+interface Properties {
+    [key: string]: Property | undefined;
+}
+interface OrderedProperties {
+    [key: string]: [Property, number] | undefined;
+}
+type Entities = Array<Entity>;
+interface Entity {
+    entity: string;
+    data: Properties;
+    nested: Entities;
+    context: OrderedProperties;
+}
+type ConsentHandler = Record<string, AnyFunction>;
+type ActionHandler = AnyFunction;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type PromiseOrValue<T> = T | Promise<T>;
+
+type walkeros_ActionHandler = ActionHandler;
+type walkeros_AnyFunction = AnyFunction;
+type walkeros_AnyObject<T = unknown> = AnyObject<T>;
+type walkeros_Consent = Consent;
+type walkeros_ConsentHandler = ConsentHandler;
+type walkeros_DeepPartial<T> = DeepPartial<T>;
+type walkeros_DeepPartialEvent = DeepPartialEvent;
+type walkeros_Elb = Elb;
+type walkeros_Entities = Entities;
+type walkeros_Entity = Entity;
+type walkeros_Event = Event;
+type walkeros_Events = Events;
+type walkeros_OrderedProperties = OrderedProperties;
+type walkeros_PartialEvent = PartialEvent;
+type walkeros_PromiseOrValue<T> = PromiseOrValue<T>;
+type walkeros_Properties = Properties;
+type walkeros_Property = Property;
+type walkeros_PropertyType = PropertyType;
+type walkeros_SingleOrArray<T> = SingleOrArray<T>;
+type walkeros_Source = Source;
+type walkeros_SourceType = SourceType;
+type walkeros_User = User;
+type walkeros_Version = Version;
+declare namespace walkeros {
+  export type { walkeros_ActionHandler as ActionHandler, walkeros_AnyFunction as AnyFunction, walkeros_AnyObject as AnyObject, walkeros_Consent as Consent, walkeros_ConsentHandler as ConsentHandler, walkeros_DeepPartial as DeepPartial, walkeros_DeepPartialEvent as DeepPartialEvent, walkeros_Elb as Elb, walkeros_Entities as Entities, walkeros_Entity as Entity, walkeros_Event as Event, walkeros_Events as Events, walkeros_OrderedProperties as OrderedProperties, walkeros_PartialEvent as PartialEvent, walkeros_PromiseOrValue as PromiseOrValue, walkeros_Properties as Properties, walkeros_Property as Property, walkeros_PropertyType as PropertyType, walkeros_SingleOrArray as SingleOrArray, walkeros_Source as Source, walkeros_SourceType as SourceType, walkeros_User as User, walkeros_Version as Version };
+}
+
+type StorageType = 'local' | 'session' | 'cookie';
+declare const Const: {
+    readonly Utils: {
+        readonly Storage: {
+            readonly Local: "local";
+            readonly Session: "session";
+            readonly Cookie: "cookie";
+        };
+    };
+};
+
+type SendDataValue = Property | Properties;
+type SendHeaders = {
+    [key: string]: string;
+};
+interface SendResponse {
+    ok: boolean;
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Anonymizes an IPv4 address by setting the last octet to 0.
+ *
+ * @param ip The IP address to anonymize.
+ * @returns The anonymized IP address or an empty string if the IP is invalid.
+ */
+declare function anonymizeIP(ip: string): string;
+
+/**
+ * Flow Configuration Utilities
+ *
+ * Functions for resolving and processing Flow configurations.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Convert package name to valid JavaScript variable name.
+ * Used for deterministic default import naming.
+ * @example
+ * packageNameToVariable('@walkeros/server-destination-api')
+ * // → '_walkerosServerDestinationApi'
+ */
+declare function packageNameToVariable(packageName: string): string;
+/**
+ * Get resolved flow configuration for a named flow.
+ *
+ * @param setup - The complete setup configuration
+ * @param flowName - Flow name (auto-selected if only one exists)
+ * @returns Resolved Config with variables/definitions interpolated and $refs resolved
+ * @throws Error if flow selection is required but not specified, or flow not found
+ *
+ * @example
+ * ```typescript
+ * import { getFlowConfig } from '@walkeros/core';
+ *
+ * const setup = JSON.parse(fs.readFileSync('walkeros.config.json', 'utf8'));
+ *
+ * // Auto-select if only one flow
+ * const config = getFlowConfig(setup);
+ *
+ * // Or specify flow
+ * const prodConfig = getFlowConfig(setup, 'production');
+ * ```
+ */
+declare function getFlowConfig(setup: Setup, flowName?: string): Config$4;
+/**
+ * Get platform from config (web or server).
+ *
+ * @param config - Flow configuration
+ * @returns "web" or "server"
+ * @throws Error if neither web nor server is present
+ *
+ * @example
+ * ```typescript
+ * import { getPlatform } from '@walkeros/core';
+ *
+ * const platform = getPlatform(config);
+ * // Returns "web" or "server"
+ * ```
+ */
+declare function getPlatform(config: Config$4): 'web' | 'server';
+
+/**
+ * @interface Assign
+ * @description Options for the assign function.
+ * @property merge - Merge array properties instead of overriding them.
+ * @property shallow - Create a shallow copy instead of updating the target object.
+ * @property extend - Extend the target with new properties instead of only updating existing ones.
+ */
+interface Assign {
+    merge?: boolean;
+    shallow?: boolean;
+    extend?: boolean;
+}
+/**
+ * Merges objects with advanced options.
+ *
+ * @template T, U
+ * @param target - The target object to merge into.
+ * @param obj - The source object to merge from.
+ * @param options - Options for merging.
+ * @returns The merged object.
+ */
+declare function assign<T extends object, U extends object>(target: T, obj?: U, options?: Assign): T & U;
+
+/**
+ * Gets a value from an object by a dot-notation string.
+ * Supports wildcards for arrays.
+ *
+ * @example
+ * getByPath({ data: { id: 1 } }, "data.id") // Returns 1
+ *
+ * @param event - The object to get the value from.
+ * @param key - The dot-notation string.
+ * @param defaultValue - The default value to return if the key is not found.
+ * @returns The value from the object or the default value.
+ */
+declare function getByPath(event: unknown, key?: string, defaultValue?: unknown): unknown;
+/**
+ * Sets a value in an object by a dot-notation string.
+ *
+ * @param obj - The object to set the value in.
+ * @param key - The dot-notation string.
+ * @param value - The value to set.
+ * @returns A new object with the updated value.
+ */
+declare function setByPath<T = unknown>(obj: T, key: string, value: unknown): T;
+
+/**
+ * Casts a value to a specific type.
+ *
+ * @param value The value to cast.
+ * @returns The casted value.
+ */
+declare function castValue(value: unknown): PropertyType;
+
+/**
+ * Creates a deep clone of a value.
+ * Supports primitive values, objects, arrays, dates, and regular expressions.
+ * Handles circular references.
+ *
+ * @template T
+ * @param org - The value to clone.
+ * @param visited - A map of visited objects to handle circular references.
+ * @returns The cloned value.
+ */
+declare function clone<T>(org: T, visited?: WeakMap<object, unknown>): T;
+
+/**
+ * Checks if the required consent is granted.
+ *
+ * @param required - The required consent states.
+ * @param state - The current consent states.
+ * @param individual - Individual consent states to prioritize.
+ * @returns The granted consent states or false if not granted.
+ */
+declare function getGrantedConsent(required: Consent | undefined, state?: Consent, individual?: Consent): false | Consent;
+
+/**
+ * Creates a new destination instance by merging a base destination with additional configuration.
+ *
+ * This utility enables elegant destination configuration while avoiding config side-effects
+ * that could occur when reusing destination objects across multiple collector instances.
+ *
+ * @param baseDestination - The base destination to extend
+ * @param config - Additional configuration to merge with the base destination's config
+ * @returns A new destination instance with merged configuration
+ *
+ * @example
+ * ```typescript
+ * // Types are inferred automatically from destinationGtag
+ * elb('walker destination', createDestination(destinationGtag, {
+ *   settings: { ga4: { measurementId: 'G-123' } }
+ * }));
+ * ```
+ */
+declare function createDestination<I extends Instance$2>(baseDestination: I, config: Partial<Config$5<TypesOf$1<I>>>): I;
+
+/**
+ * Creates a complete event with default values.
+ * Used for testing and debugging.
+ *
+ * @param props - Properties to override the default values.
+ * @returns A complete event.
+ */
+declare function createEvent(props?: DeepPartialEvent): Event;
+/**
+ * Creates a complete event with default values based on the event name.
+ * Used for testing and debugging.
+ *
+ * @param name - The name of the event to create.
+ * @param props - Properties to override the default values.
+ * @returns A complete event.
+ */
+declare function getEvent(name?: string, props?: DeepPartialEvent): Event;
+
+/**
+ * Generates a random string of a given length.
+ *
+ * @param length - The length of the random string.
+ * @returns The random string.
+ */
+declare function getId(length?: number): string;
+
+interface MarketingParameters {
+    [key: string]: string;
+}
+/**
+ * Extracts marketing parameters from a URL.
+ *
+ * @param url - The URL to extract the parameters from.
+ * @param custom - Custom marketing parameters to extract.
+ * @returns The extracted marketing parameters.
+ */
+declare function getMarketingParameters(url: URL, custom?: MarketingParameters): Properties;
+
+/**
+ * Creates a debounced function that delays invoking `fn` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `fn` invocations and a `flush` method to immediately invoke them.
+ *
+ * @template P, R
+ * @param fn The function to debounce.
+ * @param wait The number of milliseconds to delay.
+ * @param immediate Trigger the function on the leading edge, instead of the trailing.
+ * @returns The new debounced function.
+ */
+declare function debounce<P extends unknown[], R>(fn: (...args: P) => R, wait?: number, immediate?: boolean): (...args: P) => Promise<R>;
+declare function throttle<P extends unknown[], R>(fn: (...args: P) => R | undefined, delay?: number): (...args: P) => R | undefined;
+
+/**
+ * Checks if a value is an arguments object.
+ *
+ * @param value The value to check.
+ * @returns True if the value is an arguments object, false otherwise.
+ */
+declare function isArguments(value: unknown): value is IArguments;
+/**
+ * Checks if a value is an array.
+ *
+ * @param value The value to check.
+ * @returns True if the value is an array, false otherwise.
+ */
+declare function isArray<T>(value: unknown): value is T[];
+/**
+ * Checks if a value is a boolean.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a boolean, false otherwise.
+ */
+declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if an entity is a walker command.
+ *
+ * @param entity The entity to check.
+ * @returns True if the entity is a walker command, false otherwise.
+ */
+declare function isCommand(entity: string): entity is "walker";
+/**
+ * Checks if a value is defined.
+ *
+ * @param value The value to check.
+ * @returns True if the value is defined, false otherwise.
+ */
+declare function isDefined<T>(val: T | undefined): val is T;
+/**
+ * Checks if a value is an element or the document.
+ *
+ * @param elem The value to check.
+ * @returns True if the value is an element or the document, false otherwise.
+ */
+declare function isElementOrDocument(elem: unknown): elem is Element;
+/**
+ * Checks if a value is a function.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a function, false otherwise.
+ */
+declare function isFunction(value: unknown): value is Function;
+/**
+ * Checks if a value is a number.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a number, false otherwise.
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is an object.
+ *
+ * @param value The value to check.
+ * @returns True if the value is an object, false otherwise.
+ */
+declare function isObject(value: unknown): value is AnyObject;
+/**
+ * Checks if two variables have the same type.
+ *
+ * @param variable The first variable.
+ * @param type The second variable.
+ * @returns True if the variables have the same type, false otherwise.
+ */
+declare function isSameType<T>(variable: unknown, type: T): variable is typeof type;
+/**
+ * Checks if a value is a string.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a string, false otherwise.
+ */
+declare function isString(value: unknown): value is string;
+
+/**
+ * Create a logger instance
+ *
+ * @param config - Logger configuration
+ * @returns Logger instance with all log methods and scoping support
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const logger = createLogger({ level: 'DEBUG' });
+ * logger.info('Hello world');
+ *
+ * // With scoping
+ * const destLogger = logger.scope('gtag').scope('myInstance');
+ * destLogger.debug('Processing event'); // DEBUG [gtag:myInstance] Processing event
+ *
+ * // With custom handler
+ * const logger = createLogger({
+ *   handler: (level, message, context, scope, originalHandler) => {
+ *     // Custom logic (e.g., send to Sentry)
+ *     originalHandler(level, message, context, scope);
+ *   }
+ * });
+ * ```
+ *
+ * // TODO: Consider compile-time stripping of debug logs in production builds
+ * // e.g., if (__DEV__) { logger.debug(...) }
+ */
+declare function createLogger(config?: Config$3): Instance$1;
+
+/**
+ * Gets the mapping for an event.
+ *
+ * @param event The event to get the mapping for (can be partial or full).
+ * @param mapping The mapping rules.
+ * @returns The mapping result.
+ */
+declare function getMappingEvent(event: DeepPartialEvent | PartialEvent | Event, mapping?: Rules): Promise<Result>;
+/**
+ * Gets a value from a mapping.
+ *
+ * @param value The value to get the mapping from.
+ * @param data The mapping data.
+ * @param options The mapping options.
+ * @returns The mapped value.
+ */
+declare function getMappingValue(value: DeepPartialEvent | unknown | undefined, data?: Data, options?: Options$1): Promise<Property | undefined>;
+/**
+ * Processes an event through mapping configuration.
+ *
+ * This is the unified mapping logic used by both sources and destinations.
+ * It applies transformations in this order:
+ * 1. Config-level policy - modifies the event itself (global rules)
+ * 2. Mapping rules - finds matching rule based on entity-action
+ * 3. Event-level policy - modifies the event based on specific mapping rule
+ * 4. Data transformation - creates context data
+ * 5. Ignore check and name override
+ *
+ * Sources can pass partial events, destinations pass full events.
+ * getMappingValue works with both partial and full events.
+ *
+ * @param event - The event to process (can be partial or full, will be mutated by policies)
+ * @param config - Mapping configuration (mapping, data, policy, consent)
+ * @param collector - Collector instance for context
+ * @returns Object with transformed event, data, mapping rule, and ignore flag
+ */
+declare function processEventMapping<T extends DeepPartialEvent | Event>(event: T, config: Config$2, collector: Instance$3): Promise<{
+    event: T;
+    data?: Property;
+    mapping?: Rule;
+    mappingKey?: string;
+    ignore: boolean;
+}>;
+
+/**
+ * Environment mocking utilities for walkerOS destinations
+ *
+ * Provides standardized tools for intercepting function calls in environment objects,
+ * enabling consistent testing patterns across all destinations.
+ */
+type InterceptorFn = (path: string[], args: unknown[], original?: Function) => unknown;
+/**
+ * Creates a proxied environment that intercepts function calls
+ *
+ * Uses Proxy to wrap environment objects and capture all function calls,
+ * allowing for call recording, mocking, or simulation.
+ *
+ * @param env - The environment object to wrap
+ * @param interceptor - Function called for each intercepted call
+ * @returns Proxied environment with interceptor applied
+ *
+ * @example
+ * ```typescript
+ * const calls: Array<{ path: string[]; args: unknown[] }> = [];
+ *
+ * const testEnv = mockEnv(env.push, (path, args) => {
+ *   calls.push({ path, args });
+ * });
+ *
+ * // Use testEnv with destination
+ * await destination.push(event, { env: testEnv });
+ *
+ * // Analyze captured calls
+ * expect(calls).toContainEqual({
+ *   path: ['window', 'gtag'],
+ *   args: ['event', 'purchase', { value: 99.99 }]
+ * });
+ * ```
+ */
+declare function mockEnv<T extends object>(env: T, interceptor: InterceptorFn): T;
+/**
+ * Traverses environment object and replaces values using a replacer function
+ *
+ * Alternative to mockEnv for environments where Proxy is not suitable.
+ * Performs deep traversal and allows value transformation at each level.
+ *
+ * @param env - The environment object to traverse
+ * @param replacer - Function to transform values during traversal
+ * @returns New environment object with transformed values
+ *
+ * @example
+ * ```typescript
+ * const recordedCalls: APICall[] = [];
+ *
+ * const recordingEnv = traverseEnv(originalEnv, (value, path) => {
+ *   if (typeof value === 'function') {
+ *     return (...args: unknown[]) => {
+ *       recordedCalls.push({
+ *         path: path.join('.'),
+ *         args: structuredClone(args)
+ *       });
+ *       return value(...args);
+ *     };
+ *   }
+ *   return value;
+ * });
+ * ```
+ */
+declare function traverseEnv<T extends object>(env: T, replacer: (value: unknown, path: string[]) => unknown): T;
+
+/**
+ * Mock logger instance for testing
+ * Includes all logger methods as jest.fn() plus tracking of scoped loggers
+ * Extends Instance to ensure type compatibility
+ */
+interface MockLogger extends Instance$1 {
+    error: jest.Mock;
+    info: jest.Mock;
+    debug: jest.Mock;
+    throw: jest.Mock<never, [string | Error, unknown?]>;
+    scope: jest.Mock<MockLogger, [string]>;
+    /**
+     * Array of all scoped loggers created by this logger
+     * Useful for asserting on scoped logger calls in tests
+     */
+    scopedLoggers: MockLogger[];
+}
+/**
+ * Create a mock logger for testing
+ * All methods are jest.fn() that can be used for assertions
+ *
+ * @example
+ * ```typescript
+ * const mockLogger = createMockLogger();
+ *
+ * // Use in code under test
+ * someFunction(mockLogger);
+ *
+ * // Assert on calls
+ * expect(mockLogger.error).toHaveBeenCalledWith('error message');
+ *
+ * // Assert on scoped logger
+ * const scoped = mockLogger.scopedLoggers[0];
+ * expect(scoped.debug).toHaveBeenCalledWith('debug in scope');
+ * ```
+ */
+declare function createMockLogger(): MockLogger;
+
+/**
+ * Checks if a value is a valid property type.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a valid property type, false otherwise.
+ */
+declare function isPropertyType(value: unknown): value is PropertyType;
+/**
+ * Filters a value to only include valid property types.
+ *
+ * @param value The value to filter.
+ * @returns The filtered value or undefined.
+ */
+declare function filterValues(value: unknown): Property | undefined;
+/**
+ * Casts a value to a valid property type.
+ *
+ * @param value The value to cast.
+ * @returns The casted value or undefined.
+ */
+declare function castToProperty(value: unknown): Property | undefined;
+
+/**
+ * Converts a request string to a data object.
+ *
+ * @param parameter The request string to convert.
+ * @returns The data object or undefined.
+ */
+declare function requestToData(parameter: unknown): AnyObject | undefined;
+/**
+ * Converts a data object to a request string.
+ *
+ * @param data The data object to convert.
+ * @returns The request string.
+ */
+declare function requestToParameter(data: AnyObject | PropertyType): string;
+
+/**
+ * Transforms data to a string.
+ *
+ * @param data The data to transform.
+ * @returns The transformed data.
+ */
+declare function transformData(data?: SendDataValue): string | undefined;
+/**
+ * Gets the headers for a request.
+ *
+ * @param headers The headers to merge with the default headers.
+ * @returns The merged headers.
+ */
+declare function getHeaders(headers?: SendHeaders): SendHeaders;
+
+/**
+ * Throws an error.
+ *
+ * @param error The error to throw.
+ */
+declare function throwError(error: unknown): never;
+
+/**
+ * Trims quotes and whitespaces from a string.
+ *
+ * @param str The string to trim.
+ * @returns The trimmed string.
+ */
+declare function trim(str: string): string;
+
+/**
+ * A utility function that wraps a function in a try-catch block.
+ *
+ * @template P, R, S
+ * @param fn The function to wrap.
+ * @param onError A function to call when an error is caught.
+ * @param onFinally A function to call in the finally block.
+ * @returns The wrapped function.
+ */
+declare function tryCatch<P extends unknown[], R, S>(fn: (...args: P) => R | undefined, onError: (err: unknown) => S, onFinally?: () => void): (...args: P) => R | S;
+declare function tryCatch<P extends unknown[], R>(fn: (...args: P) => R | undefined, onError?: undefined, onFinally?: () => void): (...args: P) => R | undefined;
+/**
+ * A utility function that wraps an async function in a try-catch block.
+ *
+ * @template P, R, S
+ * @param fn The async function to wrap.
+ * @param onError A function to call when an error is caught.
+ * @param onFinally A function to call in the finally block.
+ * @returns The wrapped async function.
+ */
+declare function tryCatchAsync<P extends unknown[], R, S>(fn: (...args: P) => R, onError: (err: unknown) => S, onFinally?: () => void | Promise<void>): (...args: P) => Promise<R | S>;
+declare function tryCatchAsync<P extends unknown[], R>(fn: (...args: P) => R, onError?: undefined, onFinally?: () => void | Promise<void>): (...args: P) => Promise<R | undefined>;
+
+/**
+ * A utility function that wraps a function with hooks.
+ *
+ * @template P, R
+ * @param fn The function to wrap.
+ * @param name The name of the function.
+ * @param hooks The hooks to use.
+ * @returns The wrapped function.
+ */
+declare function useHooks<P extends unknown[], R>(fn: (...args: P) => R, name: string, hooks: Functions): (...args: P) => R;
+
+/**
+ * Parses a user agent string to extract browser, OS, and device information.
+ *
+ * @param userAgent The user agent string to parse.
+ * @returns An object containing the parsed user agent information.
+ */
+declare function parseUserAgent(userAgent?: string): User;
+/**
+ * Gets the browser name from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The browser name or undefined.
+ */
+declare function getBrowser(userAgent: string): string | undefined;
+/**
+ * Gets the browser version from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The browser version or undefined.
+ */
+declare function getBrowserVersion(userAgent: string): string | undefined;
+/**
+ * Gets the OS name from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The OS name or undefined.
+ */
+declare function getOS(userAgent: string): string | undefined;
+/**
+ * Gets the OS version from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The OS version or undefined.
+ */
+declare function getOSVersion(userAgent: string): string | undefined;
+/**
+ * Gets the device type from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The device type or undefined.
+ */
+declare function getDeviceType(userAgent: string): string | undefined;
+
+/**
+ * Validates an event against a set of contracts.
+ *
+ * @param obj The event to validate.
+ * @param customContracts The custom contracts to use.
+ * @returns The validated event.
+ */
+declare function validateEvent(obj: unknown, customContracts?: Contracts): Event | never;
+/**
+ * Validates a property against a schema.
+ *
+ * @param obj The object to validate.
+ * @param key The key of the property to validate.
+ * @param value The value of the property to validate.
+ * @param schema The schema to validate against.
+ * @returns The validated property.
+ */
+declare function validateProperty(obj: AnyObject, key: string, value: unknown, schema: Property$1): Property | never;
+
+/**
+ * Inline Code Wrapping Utilities
+ *
+ * Converts inline code strings to executable functions.
+ * Used for mapping properties: condition, fn, validate.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Wrap inline code string as Condition function.
+ *
+ * @param code - Inline code string
+ * @returns Condition function matching Mapping.Condition signature
+ *
+ * @remarks
+ * Available parameters in code:
+ * - `value` - The event or partial event being processed
+ * - `mapping` - Current mapping configuration
+ * - `collector` - Collector instance
+ *
+ * If code has no explicit return, it's auto-wrapped with `return`.
+ *
+ * @example
+ * ```typescript
+ * // One-liner (auto-wrapped)
+ * const fn = wrapCondition('value.data.total > 100');
+ * fn(event, mapping, collector); // returns boolean
+ *
+ * // Multi-statement (explicit return)
+ * const fn = wrapCondition('const threshold = 100; return value.data.total > threshold');
+ * ```
+ */
+declare function wrapCondition(code: string): Condition;
+/**
+ * Wrap inline code string as Fn function.
+ *
+ * @param code - Inline code string
+ * @returns Fn function matching Mapping.Fn signature
+ *
+ * @remarks
+ * Available parameters in code:
+ * - `value` - The event or partial event being processed
+ * - `mapping` - Current mapping configuration
+ * - `options` - Options object with consent and collector
+ *
+ * If code has no explicit return, it's auto-wrapped with `return`.
+ *
+ * @example
+ * ```typescript
+ * // One-liner (auto-wrapped)
+ * const fn = wrapFn('value.user.email.split("@")[1]');
+ * fn(event, mapping, options); // returns domain
+ *
+ * // Multi-statement (explicit return)
+ * const fn = wrapFn('const parts = value.user.email.split("@"); return parts[1].toUpperCase()');
+ * ```
+ */
+declare function wrapFn(code: string): Fn;
+/**
+ * Wrap inline code string as Validate function.
+ *
+ * @param code - Inline code string
+ * @returns Validate function matching Mapping.Validate signature
+ *
+ * @remarks
+ * Available parameters in code:
+ * - `value` - The current value being validated
+ *
+ * If code has no explicit return, it's auto-wrapped with `return`.
+ *
+ * @example
+ * ```typescript
+ * // One-liner (auto-wrapped)
+ * const fn = wrapValidate('value && value.length > 0');
+ * fn('hello'); // returns true
+ *
+ * // Multi-statement (explicit return)
+ * const fn = wrapValidate('if (!value) return false; return value.length > 0');
+ * ```
+ */
+declare function wrapValidate(code: string): Validate;
+
+export { collector as Collector, Const, data as Data, destination as Destination, elb as Elb, flow as Flow, hooks as Hooks, Level, logger as Logger, mapping as Mapping, type MarketingParameters, type MockLogger, on as On, request as Request, schema as Schema, type SendDataValue, type SendHeaders, type SendResponse, source as Source, type StorageType, walkeros as WalkerOS, anonymizeIP, assign, castToProperty, castValue, clone, createDestination, createEvent, createLogger, createMockLogger, debounce, filterValues, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowConfig, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, getPlatform, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isSameType, isString, mockEnv, packageNameToVariable, parseUserAgent, processEventMapping, requestToData, requestToParameter, setByPath, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateEvent, validateProperty, wrapCondition, wrapFn, wrapValidate };