@walkeros/core 0.6.0 → 0.8.0

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 /**
  * Core collector configuration interface
  */
-interface Config$6 {
+interface Config$7 {
     /** Whether to run collector automatically */
     run?: boolean;
     /** Version for event tagging */
@@ -11,12 +11,12 @@ interface Config$6 {
     /** Static session data even on a new run */
     sessionStatic: Partial<SessionData>;
     /** Logger configuration */
-    logger?: Config$3;
+    logger?: Config$4;
 }
 /**
  * Initialization configuration that extends Config with initial state
  */
-interface InitConfig extends Partial<Config$6> {
+interface InitConfig extends Partial<Config$7> {
     /** Initial consent state */
     consent?: Consent;
     /** Initial user data */
@@ -27,6 +27,8 @@ interface InitConfig extends Partial<Config$6> {
     sources?: InitSources;
     /** Destination configurations */
     destinations?: InitDestinations;
+    /** Transformer configurations */
+    transformers?: InitTransformers;
     /** Initial custom properties */
     custom?: Properties;
 }
@@ -46,30 +48,46 @@ interface Sources {
     [id: string]: Instance;
 }
 interface Destinations$1 {
-    [id: string]: Instance$2;
+    [id: string]: Instance$3;
+}
+interface Transformers$1 {
+    [id: string]: Instance$1;
+}
+/**
+ * Resolved transformer chains for a flow.
+ */
+interface TransformerChain {
+    /** Ordered transformer IDs to run before collector (from source.next) */
+    pre: string[];
+    /** Per-destination transformer chains (from destination.before) */
+    post: Record<string, string[]>;
 }
 type CommandType = 'action' | 'config' | 'consent' | 'context' | 'destination' | 'elb' | 'globals' | 'hook' | 'init' | 'link' | 'run' | 'user' | 'walker' | string;
 /**
- * Context passed to collector.push for source mapping
+ * Options passed to collector.push() from sources.
+ * NOT a Context - just push metadata.
  */
-interface PushContext$1 {
-    mapping?: Config$2;
+interface PushOptions {
+    id?: string;
+    ingest?: unknown;
+    mapping?: Config$3;
+    preChain?: string[];
 }
 /**
  * Push function signature - handles events only
  */
 interface PushFn$1 {
-    (event: DeepPartialEvent, context?: PushContext$1): Promise<PushResult>;
+    (event: DeepPartialEvent, options?: PushOptions): Promise<PushResult>;
 }
 /**
  * Command function signature - handles walker commands only
  */
 interface CommandFn {
-    (command: 'config', config: Partial<Config$6>): Promise<PushResult>;
+    (command: 'config', config: Partial<Config$7>): 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>;
+    <T extends Types$3>(command: 'destination', destination: Init$2<T> | Instance$3<T>, config?: Config$6<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: 'on', type: Types$2, rules: SingleOrArray<Options>): Promise<PushResult>;
     (command: 'user', user: User): Promise<PushResult>;
     (command: 'run', runState?: {
         consent?: Consent;
@@ -79,20 +97,22 @@ interface CommandFn {
     }): Promise<PushResult>;
     (command: string, data?: unknown, options?: unknown): Promise<PushResult>;
 }
-interface Instance$3 {
+interface Instance$4 {
     push: PushFn$1;
     command: CommandFn;
     allowed: boolean;
-    config: Config$6;
+    config: Config$7;
     consent: Consent;
     count: number;
     custom: Properties;
     sources: Sources;
     destinations: Destinations$1;
+    transformers: Transformers$1;
+    transformerChain: TransformerChain;
     globals: Properties;
     group: string;
     hooks: Functions;
-    logger: Instance$1;
+    logger: Instance$2;
     on: OnConfig;
     queue: Events;
     round: number;
@@ -105,10 +125,28 @@ interface Instance$3 {
 type collector_CommandFn = CommandFn;
 type collector_CommandType = CommandType;
 type collector_InitConfig = InitConfig;
+type collector_PushOptions = PushOptions;
 type collector_SessionData = SessionData;
 type collector_Sources = Sources;
+type collector_TransformerChain = TransformerChain;
 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 };
+  export type { collector_CommandFn as CommandFn, collector_CommandType as CommandType, Config$7 as Config, Destinations$1 as Destinations, collector_InitConfig as InitConfig, Instance$4 as Instance, PushFn$1 as PushFn, collector_PushOptions as PushOptions, collector_SessionData as SessionData, collector_Sources as Sources, collector_TransformerChain as TransformerChain, Transformers$1 as Transformers };
+}
+
+/**
+ * Base context interface for walkerOS stages.
+ * Sources, Transformers, and Destinations extend this.
+ */
+interface Base<C = unknown, E = unknown> {
+    collector: Instance$4;
+    logger: Instance$2;
+    config: C;
+    env: E;
+}
+
+type context_Base<C = unknown, E = unknown> = Base<C, E>;
+declare namespace context {
+  export type { context_Base as Base };
 }
 
 interface Contract$1 {
@@ -121,7 +159,7 @@ interface Globals {
     [name: string]: Global;
 }
 interface Contexts {
-    [name: string]: Context$3;
+    [name: string]: Context$5;
 }
 interface Entities$1 {
     [name: string]: Entity$1;
@@ -131,7 +169,7 @@ interface Properties$2 {
 }
 interface Global extends Property$2 {
 }
-interface Context$3 extends Property$2 {
+interface Context$5 extends Property$2 {
 }
 interface Entity$1 {
     data: Properties$2;
@@ -160,7 +198,7 @@ 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 };
+  export type { data_Action as Action, data_Actions as Actions, Context$5 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 };
 }
 
 /**
@@ -170,7 +208,7 @@ declare namespace data {
  * their runtime environment requirements. Platform-specific extensions
  * should extend this interface.
  */
-interface BaseEnv$1 {
+interface BaseEnv$2 {
     /**
      * Generic global properties that destinations may require
      * Platform-specific implementations can extend this interface
@@ -181,7 +219,7 @@ interface BaseEnv$1 {
  * 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> {
+interface Types$3<S = unknown, M = unknown, E = BaseEnv$2, I = S> {
     settings: S;
     initSettings: I;
     mapping: M;
@@ -190,7 +228,7 @@ interface Types$2<S = unknown, M = unknown, E = BaseEnv$1, I = S> {
 /**
  * Generic constraint for Types - ensures T has required properties for indexed access
  */
-type TypesGeneric$1 = {
+type TypesGeneric$2 = {
     settings: any;
     initSettings: any;
     mapping: any;
@@ -199,78 +237,74 @@ type TypesGeneric$1 = {
 /**
  * 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'];
+type Settings$2<T extends TypesGeneric$2 = Types$3> = T['settings'];
+type InitSettings$2<T extends TypesGeneric$2 = Types$3> = T['initSettings'];
+type Mapping$1<T extends TypesGeneric$2 = Types$3> = T['mapping'];
+type Env$2<T extends TypesGeneric$2 = Types$3> = 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>;
+type TypesOf$2<I> = I extends Instance$3<infer T> ? T : never;
+interface Instance$3<T extends TypesGeneric$2 = Types$3> {
+    config: Config$6<T>;
     queue?: Events;
     dlq?: DLQ;
     batches?: BatchRegistry<Mapping$1<T>>;
     type?: string;
-    env?: Env$1<T>;
-    init?: InitFn<T>;
+    env?: Env$2<T>;
+    init?: InitFn$1<T>;
     push: PushFn<T>;
     pushBatch?: PushBatchFn<T>;
     on?: OnFn;
 }
-interface Config$5<T extends TypesGeneric$1 = Types$2> {
+interface Config$6<T extends TypesGeneric$2 = Types$3> {
     consent?: Consent;
-    settings?: InitSettings$1<T>;
+    settings?: InitSettings$2<T>;
     data?: Value | Values;
-    env?: Env$1<T>;
+    env?: Env$2<T>;
     id?: string;
     init?: boolean;
     loadScript?: boolean;
-    logger?: Config$3;
+    logger?: Config$4;
     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>>>;
+type PartialConfig$1<T extends TypesGeneric$2 = Types$3> = Config$6<Types$3<Partial<Settings$2<T>> | Settings$2<T>, Partial<Mapping$1<T>> | Mapping$1<T>, Env$2<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> = {
+type Code<T extends TypesGeneric$2 = Types$3> = Instance$3<T> | true;
+type Init$2<T extends TypesGeneric$2 = Types$3> = {
     code: Code<T>;
-    config?: Partial<Config$5<T>>;
-    env?: Partial<Env$1<T>>;
+    config?: Partial<Config$6<T>>;
+    env?: Partial<Env$2<T>>;
 };
 interface InitDestinations {
-    [key: string]: Init$1<any>;
+    [key: string]: Init$2<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;
+    [key: string]: Instance$3;
 }
-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>>>;
+/**
+ * Context provided to destination functions.
+ * Extends base context with destination-specific properties.
+ */
+interface Context$4<T extends TypesGeneric$2 = Types$3> extends Base<Config$6<T>, Env$2<T>> {
+    id: string;
     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 PushContext<T extends TypesGeneric$2 = Types$3> extends Context$4<T> {
+    ingest?: unknown;
+    rule?: Rule<Mapping$1<T>>;
 }
-interface PushBatchContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
-    mapping?: Rule<Mapping$1<T>>;
+interface PushBatchContext<T extends TypesGeneric$2 = Types$3> extends Context$4<T> {
+    ingest?: unknown;
+    rule?: 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 InitFn$1<T extends TypesGeneric$2 = Types$3> = (context: Context$4<T>) => PromiseOrValue<void | false | Config$6<T>>;
+type PushFn<T extends TypesGeneric$2 = Types$3> = (event: Event, context: PushContext<T>) => PromiseOrValue<void | unknown>;
+type PushBatchFn<T extends TypesGeneric$2 = Types$3> = (batch: Batch<Mapping$1<T>>, context: PushBatchContext<T>) => void;
 type PushEvent<Mapping = unknown> = {
     event: Event;
     mapping?: Rule<Mapping>;
@@ -289,38 +323,32 @@ interface BatchRegistry<Mapping> {
     };
 }
 type Data$1 = Property | undefined | Array<Property | undefined>;
-type Ref = {
-    id: string;
-    destination: Instance$2;
-};
+interface Ref {
+    type: string;
+    data?: unknown;
+    error?: unknown;
+}
 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_Code<T extends TypesGeneric$2 = Types$3> = 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_PushBatchContext<T extends TypesGeneric$2 = Types$3> = PushBatchContext<T>;
+type destination_PushBatchFn<T extends TypesGeneric$2 = Types$3> = PushBatchFn<T>;
+type destination_PushContext<T extends TypesGeneric$2 = Types$3> = 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_PushFn<T extends TypesGeneric$2 = Types$3> = 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 };
+  export type { BaseEnv$2 as BaseEnv, destination_Batch as Batch, destination_BatchRegistry as BatchRegistry, destination_Code as Code, Config$6 as Config, Context$4 as Context, destination_DLQ as DLQ, Data$1 as Data, destination_Destinations as Destinations, Env$2 as Env, Init$2 as Init, destination_InitDestinations as InitDestinations, InitFn$1 as InitFn, InitSettings$2 as InitSettings, Instance$3 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, Settings$2 as Settings, Types$3 as Types, TypesGeneric$2 as TypesGeneric, TypesOf$2 as TypesOf };
 }
 
 interface EventFn<R = Promise<PushResult>> {
@@ -328,14 +356,14 @@ interface EventFn<R = Promise<PushResult>> {
     (event: string): R;
     (event: string, data: Properties): R;
 }
-interface Fn$1<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
+interface Fn$2<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;
+    <T extends Types$3>(event: 'walker destination', destination: Init$2<T> | Instance$3<T>, config?: Config$6<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 on', type: Types$2, rules: SingleOrArray<Options>): R;
     (event: 'walker user', user: User): R;
     (event: 'walker run', runState: {
         consent?: Consent;
@@ -346,9 +374,12 @@ interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
 }
 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;
+interface PushResult {
     ok: boolean;
+    event?: Event;
+    done?: Record<string, Ref>;
+    queued?: Record<string, Ref>;
+    failed?: Record<string, Ref>;
 }
 type Layer = Array<IArguments | DeepPartialEvent | unknown[]>;
 
@@ -358,7 +389,7 @@ 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 };
+  export type { Event$1 as Event, elb_EventFn as EventFn, Fn$2 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_WalkerCommands as WalkerCommands };
 }
 
 /**
@@ -489,7 +520,7 @@ interface Setup {
      * Named flow configurations.
      * If only one flow exists, it's auto-selected.
      */
-    flows: Record<string, Config$4>;
+    flows: Record<string, Config$5>;
 }
 /**
  * Single flow configuration.
@@ -501,7 +532,7 @@ interface Setup {
  *
  * Variables/definitions cascade: source/destination > config > setup
  */
-interface Config$4 {
+interface Config$5 {
     /**
      * Web platform configuration.
      * Presence indicates web platform (browser-based tracking).
@@ -575,6 +606,34 @@ interface Config$4 {
      * ```
      */
     destinations?: Record<string, DestinationReference>;
+    /**
+     * Transformer configurations (event transformation).
+     *
+     * @remarks
+     * Transformers transform events in the pipeline:
+     * - Pre-collector: Between sources and collector
+     * - Post-collector: Between collector and destinations
+     *
+     * Key = unique transformer identifier (referenced by source.next or destination.before)
+     * Value = transformer reference with package and config
+     *
+     * @example
+     * ```json
+     * {
+     *   "transformers": {
+     *     "enrich": {
+     *       "package": "@walkeros/transformer-enricher",
+     *       "config": { "apiUrl": "https://api.example.com" },
+     *       "next": "validate"
+     *     },
+     *     "validate": {
+     *       "package": "@walkeros/transformer-validator"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    transformers?: Record<string, TransformerReference>;
     /**
      * Collector configuration (event processing).
      *
@@ -707,6 +766,77 @@ interface SourceReference {
      * Overrides flow and setup definitions.
      */
     definitions?: Definitions;
+    /**
+     * First transformer in post-source chain.
+     *
+     * @remarks
+     * Name of the transformer to execute after this source captures an event.
+     * If omitted, events route directly to the collector.
+     */
+    next?: string;
+}
+/**
+ * Transformer reference with inline package syntax.
+ *
+ * @remarks
+ * References a transformer package and provides configuration.
+ * Transformers transform events in the pipeline between sources and destinations.
+ */
+interface TransformerReference {
+    /**
+     * Package specifier with optional version.
+     *
+     * @remarks
+     * Same format as SourceReference.package
+     *
+     * @example
+     * "package": "@walkeros/transformer-enricher@1.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;
+    /**
+     * Transformer-specific configuration.
+     *
+     * @remarks
+     * Structure depends on the transformer package.
+     * Passed to the transformer's initialization function.
+     */
+    config?: unknown;
+    /**
+     * Transformer environment configuration.
+     *
+     * @remarks
+     * Environment-specific settings for the transformer.
+     * Merged with default transformer environment.
+     */
+    env?: unknown;
+    /**
+     * Next transformer in chain.
+     *
+     * @remarks
+     * Name of the next transformer to execute after this one.
+     * If omitted:
+     * - Pre-collector: routes to collector
+     * - Post-collector: routes to destination
+     */
+    next?: string;
+    /**
+     * Transformer-level variables (highest priority in cascade).
+     * Overrides flow and setup variables.
+     */
+    variables?: Variables;
+    /**
+     * Transformer-level definitions (highest priority in cascade).
+     * Overrides flow and setup definitions.
+     */
+    definitions?: Definitions;
 }
 /**
  * Destination reference with inline package syntax.
@@ -785,6 +915,14 @@ interface DestinationReference {
      * Overrides flow and setup definitions.
      */
     definitions?: Definitions;
+    /**
+     * First transformer in pre-destination chain.
+     *
+     * @remarks
+     * Name of the transformer to execute before sending events to this destination.
+     * If omitted, events are sent directly from the collector.
+     */
+    before?: string;
 }
 
 type flow_Definitions = Definitions;
@@ -794,10 +932,11 @@ type flow_Primitive = Primitive;
 type flow_Server = Server;
 type flow_Setup = Setup;
 type flow_SourceReference = SourceReference;
+type flow_TransformerReference = TransformerReference;
 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 };
+  export type { Config$5 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_TransformerReference as TransformerReference, flow_Variables as Variables, flow_Web as Web };
 }
 
 type AnyFunction$1<P extends unknown[] = never[], R = unknown> = (...args: P) => R;
@@ -864,7 +1003,7 @@ type Handler = (level: Level, message: string, context: LogContext, scope: strin
  * Logger instance with scoping support
  * All logs automatically include trace path from scoping
  */
-interface Instance$1 {
+interface Instance$2 {
     /**
      * Log an error message (always visible unless silenced)
      */
@@ -887,12 +1026,12 @@ interface Instance$1 {
      * @param name - Scope name (e.g., destination type, destination key)
      * @returns A new logger instance with the scope applied
      */
-    scope: (name: string) => Instance$1;
+    scope: (name: string) => Instance$2;
 }
 /**
  * Logger configuration options
  */
-interface Config$3 {
+interface Config$4 {
     /**
      * Minimum log level to display
      * @default Level.ERROR
@@ -915,7 +1054,7 @@ interface InternalConfig {
 /**
  * Logger factory function type
  */
-type Factory = (config?: Config$3) => Instance$1;
+type Factory = (config?: Config$4) => Instance$2;
 
 type logger_DefaultHandler = DefaultHandler;
 type logger_ErrorContext = ErrorContext;
@@ -928,14 +1067,14 @@ 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 };
+  export { type Config$4 as Config, type logger_DefaultHandler as DefaultHandler, type logger_ErrorContext as ErrorContext, type logger_Factory as Factory, type logger_Handler as Handler, type Instance$2 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> {
+interface Config$3<T = unknown> {
     consent?: Consent;
     data?: Value | Values;
     mapping?: Rules<Rule<T>>;
@@ -949,7 +1088,7 @@ interface Rules<T = Rule> {
 }
 interface Rule<Settings = unknown> {
     batch?: number;
-    batchFn?: (destination: Instance$2, collector: Instance$3) => void;
+    batchFn?: (destination: Instance$3, collector: Instance$4) => void;
     batched?: Batch<Settings>;
     condition?: Condition;
     consent?: Consent;
@@ -970,7 +1109,7 @@ type ValueType = string | ValueConfig;
 interface ValueConfig {
     condition?: Condition;
     consent?: Consent;
-    fn?: Fn;
+    fn?: Fn$1;
     key?: string;
     loop?: Loop;
     map?: Map;
@@ -978,22 +1117,21 @@ interface ValueConfig {
     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 Condition = (value: DeepPartialEvent | unknown, mapping?: Value, collector?: Instance$4) => PromiseOrValue<boolean>;
+type Fn$1 = (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;
+    collector?: Instance$4;
     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;
@@ -1006,25 +1144,25 @@ 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 };
+  export type { mapping_Condition as Condition, Config$3 as Config, mapping_Data as Data, Fn$1 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 = {
+type Config$2 = {
     consent?: Array<ConsentConfig>;
     ready?: Array<ReadyConfig>;
     run?: Array<RunConfig>;
     session?: Array<SessionConfig>;
 };
-type Types$1 = keyof Config$1;
+type Types$2 = keyof Config$2;
 interface EventContextMap {
     consent: Consent;
     session: SessionData;
     ready: undefined;
     run: undefined;
 }
-type EventContext<T extends Types$1> = EventContextMap[T];
+type EventContext<T extends Types$2> = EventContextMap[T];
 type AnyEventContext = EventContextMap[keyof EventContextMap];
-interface Context$1 {
+interface Context$3 {
     consent?: Consent;
     session?: unknown;
 }
@@ -1032,13 +1170,13 @@ type Options = ConsentConfig | ReadyConfig | RunConfig | SessionConfig;
 interface ConsentConfig {
     [key: string]: ConsentFn;
 }
-type ConsentFn = (collector: Instance$3, consent: Consent) => void;
+type ConsentFn = (collector: Instance$4, consent: Consent) => void;
 type ReadyConfig = ReadyFn;
-type ReadyFn = (collector: Instance$3) => void;
+type ReadyFn = (collector: Instance$4) => void;
 type RunConfig = RunFn;
-type RunFn = (collector: Instance$3) => void;
+type RunFn = (collector: Instance$4) => void;
 type SessionConfig = SessionFn;
-type SessionFn = (collector: Instance$3, session?: unknown) => void;
+type SessionFn = (collector: Instance$4, session?: unknown) => void;
 interface OnConfig {
     consent?: ConsentConfig[];
     ready?: ReadyConfig[];
@@ -1046,16 +1184,16 @@ interface OnConfig {
     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 OnFn<T extends TypesGeneric$2 = Types$3> = (type: Types$2, context: Context$4<T>) => PromiseOrValue<void>;
+type OnFnRuntime = (type: Types$2, context: Context$4) => 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_EventContext<T extends Types$2> = EventContext<T>;
 type on_EventContextMap = EventContextMap;
 type on_OnConfig = OnConfig;
-type on_OnFn<T extends TypesGeneric$1 = Types$2> = OnFn<T>;
+type on_OnFn<T extends TypesGeneric$2 = Types$3> = OnFn<T>;
 type on_OnFnRuntime = OnFnRuntime;
 type on_Options = Options;
 type on_ReadyConfig = ReadyConfig;
@@ -1065,10 +1203,138 @@ 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 };
+  export type { on_AnyEventContext as AnyEventContext, Config$2 as Config, on_ConsentConfig as ConsentConfig, on_ConsentFn as ConsentFn, Context$3 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$2 as Types };
 }
 
-interface Context {
+/**
+ * Base environment interface for walkerOS transformers.
+ *
+ * Minimal like Destination - just an extensible object.
+ * Transformers receive dependencies through context, not env.
+ */
+interface BaseEnv$1 {
+    [key: string]: unknown;
+}
+/**
+ * Type bundle for transformer generics.
+ * Groups Settings, InitSettings, and Env into a single type parameter.
+ * Follows the Source/Destination pattern.
+ *
+ * @template S - Settings configuration type
+ * @template E - Environment type
+ * @template I - InitSettings configuration type (user input)
+ */
+interface Types$1<S = unknown, E = BaseEnv$1, I = S> {
+    settings: S;
+    initSettings: I;
+    env: E;
+}
+/**
+ * Generic constraint for Types - ensures T has required properties for indexed access.
+ */
+type TypesGeneric$1 = {
+    settings: any;
+    initSettings: any;
+    env: any;
+};
+/**
+ * Type extractors for consistent usage with Types bundle.
+ */
+type Settings$1<T extends TypesGeneric$1 = Types$1> = T['settings'];
+type InitSettings$1<T extends TypesGeneric$1 = Types$1> = T['initSettings'];
+type Env$1<T extends TypesGeneric$1 = Types$1> = T['env'];
+/**
+ * Inference helper: Extract Types from Instance.
+ */
+type TypesOf$1<I> = I extends Instance$1<infer T> ? T : never;
+/**
+ * Transformer configuration.
+ */
+interface Config$1<T extends TypesGeneric$1 = Types$1> {
+    settings?: InitSettings$1<T>;
+    env?: Env$1<T>;
+    id?: string;
+    logger?: Config$4;
+    next?: string;
+    init?: boolean;
+}
+/**
+ * Context provided to transformer functions.
+ * Extends base context with transformer-specific properties.
+ */
+interface Context$2<T extends TypesGeneric$1 = Types$1> extends Base<Config$1<T>, Env$1<T>> {
+    id: string;
+    ingest?: unknown;
+}
+/**
+ * The main transformer function.
+ * Uses DeepPartialEvent for consistency across pre/post collector.
+ *
+ * @param event - The event to process
+ * @param context - Transformer context with collector, config, env, logger
+ * @returns event - continue with modified event
+ * @returns void - continue with current event unchanged (passthrough)
+ * @returns false - stop chain, cancel further processing
+ */
+type Fn<T extends TypesGeneric$1 = Types$1> = (event: DeepPartialEvent, context: Context$2<T>) => PromiseOrValue<DeepPartialEvent | false | void>;
+/**
+ * Optional initialization function.
+ * Called once before first push.
+ *
+ * @param context - Transformer context
+ * @returns void - initialization successful
+ * @returns false - initialization failed, skip this transformer
+ * @returns Config<T> - return updated config
+ */
+type InitFn<T extends TypesGeneric$1 = Types$1> = (context: Context$2<T>) => PromiseOrValue<void | false | Config$1<T>>;
+/**
+ * Transformer instance returned by Init function.
+ */
+interface Instance$1<T extends TypesGeneric$1 = Types$1> {
+    type: string;
+    config: Config$1<T>;
+    push: Fn<T>;
+    init?: InitFn<T>;
+    destroy?: () => void | Promise<void>;
+}
+/**
+ * Transformer initialization function.
+ * Creates a transformer instance from context.
+ */
+type Init$1<T extends TypesGeneric$1 = Types$1> = (context: Context$2<Types$1<Partial<Settings$1<T>>, Env$1<T>, InitSettings$1<T>>>) => Instance$1<T> | Promise<Instance$1<T>>;
+/**
+ * Configuration for initializing a transformer.
+ * Used in collector registration.
+ */
+type InitTransformer<T extends TypesGeneric$1 = Types$1> = {
+    code: Init$1<T>;
+    config?: Partial<Config$1<T>>;
+    env?: Partial<Env$1<T>>;
+};
+/**
+ * Transformers configuration for collector.
+ * Maps transformer IDs to their initialization configurations.
+ */
+interface InitTransformers {
+    [transformerId: string]: InitTransformer<any>;
+}
+/**
+ * Active transformer instances registry.
+ */
+interface Transformers {
+    [transformerId: string]: Instance$1;
+}
+
+type transformer_Fn<T extends TypesGeneric$1 = Types$1> = Fn<T>;
+type transformer_InitFn<T extends TypesGeneric$1 = Types$1> = InitFn<T>;
+type transformer_InitTransformer<T extends TypesGeneric$1 = Types$1> = InitTransformer<T>;
+type transformer_InitTransformers = InitTransformers;
+type transformer_Transformers = Transformers;
+declare namespace transformer {
+  export type { BaseEnv$1 as BaseEnv, Config$1 as Config, Context$2 as Context, Env$1 as Env, transformer_Fn as Fn, Init$1 as Init, transformer_InitFn as InitFn, InitSettings$1 as InitSettings, transformer_InitTransformer as InitTransformer, transformer_InitTransformers as InitTransformers, Instance$1 as Instance, Settings$1 as Settings, transformer_Transformers as Transformers, Types$1 as Types, TypesGeneric$1 as TypesGeneric, TypesOf$1 as TypesOf };
+}
+
+interface Context$1 {
     city?: string;
     country?: string;
     encoding?: string;
@@ -1081,9 +1347,8 @@ interface Context {
     [key: string]: string | undefined;
 }
 
-type request_Context = Context;
 declare namespace request {
-  export type { request_Context as Context };
+  export type { Context$1 as Context };
 }
 
 type Contracts = Array<Contract>;
@@ -1125,8 +1390,8 @@ interface BaseEnv {
     push: PushFn$1;
     command: CommandFn;
     sources?: Sources;
-    elb: Fn$1;
-    logger: Instance$1;
+    elb: Fn$2;
+    logger: Instance$2;
 }
 /**
  * Type bundle for source generics.
@@ -1138,7 +1403,7 @@ interface BaseEnv {
  * @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> {
+interface Types<S = unknown, M = unknown, P = Fn$2, E = BaseEnv, I = S> {
     settings: S;
     initSettings: I;
     mapping: M;
@@ -1167,13 +1432,26 @@ 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>> {
+interface Config<T extends TypesGeneric = Types> extends Config$3<Mapping<T>> {
     settings?: InitSettings<T>;
     env?: Env<T>;
     id?: string;
-    logger?: Config$3;
+    logger?: Config$4;
     disabled?: boolean;
     primary?: boolean;
+    /**
+     * Ingest metadata extraction mapping.
+     * Extracts values from raw request objects (Express req, Lambda event, etc.)
+     * using walkerOS mapping syntax. Extracted data flows to transformers/destinations.
+     *
+     * @example
+     * ingest: {
+     *   ip: 'req.ip',
+     *   ua: 'req.headers.user-agent',
+     *   origin: 'req.headers.origin'
+     * }
+     */
+    ingest?: Data;
 }
 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> {
@@ -1181,14 +1459,30 @@ interface Instance<T extends TypesGeneric = Types> {
     config: Config<T>;
     push: Push<T>;
     destroy?(): void | Promise<void>;
-    on?(event: Types$1, context?: unknown): void | Promise<void>;
+    on?(event: Types$2, context?: unknown): void | Promise<void>;
+}
+/**
+ * Context provided to source init function.
+ * Extends base context with source-specific properties.
+ */
+interface Context<T extends TypesGeneric = Types> extends Base<Partial<Config<T>>, Env<T>> {
+    id: string;
+    /**
+     * Sets ingest metadata for the current request.
+     * Extracts values from the raw request using config.ingest mapping.
+     * The extracted data is passed through to transformers and destinations.
+     *
+     * @param value - Raw request object (Express req, Lambda event, etc.)
+     */
+    setIngest: (value: unknown) => Promise<void>;
 }
-type Init<T extends TypesGeneric = Types> = (config: Partial<Config<T>>, env: Env<T>) => Instance<T> | Promise<Instance<T>>;
+type Init<T extends TypesGeneric = Types> = (context: Context<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;
+    next?: string;
 };
 /**
  * Sources configuration for collector.
@@ -1200,6 +1494,7 @@ interface InitSources {
 
 type source_BaseEnv = BaseEnv;
 type source_Config<T extends TypesGeneric = Types> = Config<T>;
+type source_Context<T extends TypesGeneric = Types> = Context<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>;
@@ -1210,15 +1505,15 @@ 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_Types<S = unknown, M = unknown, P = Fn$2, 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 };
+  export type { source_BaseEnv as BaseEnv, source_Config as Config, source_Context as Context, 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 Elb = Fn$2;
 type AnyFunction = (...args: unknown[]) => unknown;
 type SingleOrArray<T> = T | Array<T>;
 type Events = Array<Event>;
@@ -1398,7 +1693,7 @@ declare function packageNameToVariable(packageName: string): string;
  * const prodConfig = getFlowConfig(setup, 'production');
  * ```
  */
-declare function getFlowConfig(setup: Setup, flowName?: string): Config$4;
+declare function getFlowConfig(setup: Setup, flowName?: string): Config$5;
 /**
  * Get platform from config (web or server).
  *
@@ -1414,7 +1709,7 @@ declare function getFlowConfig(setup: Setup, flowName?: string): Config$4;
  * // Returns "web" or "server"
  * ```
  */
-declare function getPlatform(config: Config$4): 'web' | 'server';
+declare function getPlatform(config: Config$5): 'web' | 'server';
 
 /**
  * @interface Assign
@@ -1510,7 +1805,7 @@ declare function getGrantedConsent(required: Consent | undefined, state?: Consen
  * }));
  * ```
  */
-declare function createDestination<I extends Instance$2>(baseDestination: I, config: Partial<Config$5<TypesOf$1<I>>>): I;
+declare function createDestination<I extends Instance$3>(baseDestination: I, config: Partial<Config$6<TypesOf$2<I>>>): I;
 
 /**
  * Creates a complete event with default values.
@@ -1672,7 +1967,7 @@ declare function isString(value: unknown): value is string;
  * // 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;
+declare function createLogger(config?: Config$4): Instance$2;
 
 /**
  * Gets the mapping for an event.
@@ -1710,7 +2005,7 @@ declare function getMappingValue(value: DeepPartialEvent | unknown | undefined,
  * @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<{
+declare function processEventMapping<T extends DeepPartialEvent | Event>(event: T, config: Config$3, collector: Instance$4): Promise<{
     event: T;
     data?: Property;
     mapping?: Rule;
@@ -1789,7 +2084,7 @@ declare function traverseEnv<T extends object>(env: T, replacer: (value: unknown
  * Includes all logger methods as jest.fn() plus tracking of scoped loggers
  * Extends Instance to ensure type compatibility
  */
-interface MockLogger extends Instance$1 {
+interface MockLogger extends Instance$2 {
     error: jest.Mock;
     info: jest.Mock;
     debug: jest.Mock;
@@ -2043,7 +2338,7 @@ declare function wrapCondition(code: string): Condition;
  * const fn = wrapFn('const parts = value.user.email.split("@"); return parts[1].toUpperCase()');
  * ```
  */
-declare function wrapFn(code: string): Fn;
+declare function wrapFn(code: string): Fn$1;
 /**
  * Wrap inline code string as Validate function.
  *
@@ -2068,4 +2363,4 @@ declare function wrapFn(code: string): Fn;
  */
 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 };
+export { collector as Collector, Const, context as Context, 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, transformer as Transformer, 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 };