@walkeros/core 0.1.2 → 0.2.1

package/dist/index.d.mts

@@ -1,27 +1,18 @@
+import * as zod_to_json_schema from 'zod-to-json-schema';
+import { z } from 'zod';
+
 /**
  * Core collector configuration interface
  */
-interface Config$4 {
+interface Config$5 {
     /** Whether to run collector automatically */
     run?: boolean;
-    /** Initial consent state */
-    consent?: Consent;
-    /** Initial user data */
-    user?: User;
     /** Version for event tagging */
     tagging: number;
-    /** Initial global properties */
-    globals?: Properties;
     /** Static global properties even on a new run */
     globalsStatic: Properties;
     /** Static session data even on a new run */
     sessionStatic: Partial<SessionData>;
-    /** Source configurations */
-    sources?: InitSources;
-    /** Destination configurations */
-    destinations?: InitDestinations;
-    /** Initial custom properties */
-    custom?: Properties;
     /** Enable verbose logging */
     verbose: boolean;
     /** Error handler */
@@ -29,7 +20,23 @@ interface Config$4 {
     /** Log handler */
     onLog?: Log;
 }
-type InitConfig$1 = Partial<Config$4>;
+/**
+ * Initialization configuration that extends Config with initial state
+ */
+interface InitConfig extends Partial<Config$5> {
+    /** 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;
@@ -49,10 +56,41 @@ interface Destinations$1 {
     [id: string]: Instance$1;
 }
 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$5>): Promise<PushResult>;
+    (command: 'consent', consent: Consent): Promise<PushResult>;
+    <T extends Types$2>(command: 'destination', destination: Init$1<T> | Instance$1<T>, config?: Config$4<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$2 {
-    push: Fn$1;
+    push: PushFn$1;
+    command: CommandFn;
     allowed: boolean;
-    config: Config$4;
+    config: Config$5;
     consent: Consent;
     count: number;
     custom: Properties;
@@ -70,11 +108,13 @@ interface Instance$2 {
     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_CommandType as CommandType, Config$4 as Config, Destinations$1 as Destinations, InitConfig$1 as InitConfig, Instance$2 as Instance, collector_SessionData as SessionData, collector_Sources as Sources };
+  export type { collector_CommandFn as CommandFn, collector_CommandType as CommandType, Config$5 as Config, Destinations$1 as Destinations, collector_InitConfig as InitConfig, Instance$2 as Instance, PushContext$1 as PushContext, PushFn$1 as PushFn, collector_SessionData as SessionData, collector_Sources as Sources };
 }
 
 interface Contract$1 {
@@ -87,7 +127,7 @@ interface Globals {
     [name: string]: Global;
 }
 interface Contexts {
-    [name: string]: Context$2;
+    [name: string]: Context$3;
 }
 interface Entities$1 {
     [name: string]: Entity$1;
@@ -97,7 +137,7 @@ interface Properties$2 {
 }
 interface Global extends Property$2 {
 }
-interface Context$2 extends Property$2 {
+interface Context$3 extends Property$2 {
 }
 interface Entity$1 {
     data: Properties$2;
@@ -126,65 +166,106 @@ 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$2 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$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 };
 }
 
-interface Instance$1<Settings = unknown, Mapping = unknown> {
-    config: Config$3<Settings, Mapping>;
+/**
+ * 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, Mapping, and Env into a single type parameter.
+ */
+interface Types$2<S = unknown, M = unknown, E = BaseEnv$1> {
+    settings: S;
+    mapping: M;
+    env: E;
+}
+/**
+ * Generic constraint for Types - ensures T has required properties for indexed access
+ */
+type TypesGeneric$1 = {
+    settings: 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 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$1<infer T> ? T : never;
+interface Instance$1<T extends TypesGeneric$1 = Types$2> {
+    config: Config$4<T>;
     queue?: Events;
     dlq?: DLQ;
     type?: string;
-    env?: Environment$1;
-    init?: InitFn<Settings, Mapping>;
-    push: PushFn<Settings, Mapping>;
-    pushBatch?: PushBatchFn<Settings, Mapping>;
-    on?(event: Types, context?: unknown): void | Promise<void>;
+    env?: Env$1<T>;
+    init?: InitFn<T>;
+    push: PushFn<T>;
+    pushBatch?: PushBatchFn<T>;
+    on?: OnFn;
 }
-interface Config$3<Settings = unknown, Mapping = unknown> {
+interface Config$4<T extends TypesGeneric$1 = Types$2> {
     consent?: Consent;
-    settings?: Settings;
+    settings?: Settings$1<T>;
     data?: Value | Values;
-    env?: Environment$1;
+    env?: Env$1<T>;
     id?: string;
     init?: boolean;
     loadScript?: boolean;
-    mapping?: Rules<Rule<Mapping>>;
-    policy?: Policy;
+    mapping?: Rules<Rule<Mapping$1<T>>>;
+    policy?: Policy$1;
     queue?: boolean;
     verbose?: boolean;
     onError?: Error;
     onLog?: Log;
 }
-type PartialConfig<Settings = unknown, Mapping = unknown> = Config$3<Partial<Settings> | Settings, Partial<Mapping> | Mapping>;
-interface Policy {
+type PartialConfig$1<T extends TypesGeneric$1 = Types$2> = Config$4<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 Init$1<Settings = unknown, Mapping = unknown> = {
-    code: Instance$1<Settings, Mapping>;
-    config?: Partial<Config$3<Settings, Mapping>>;
-    env?: Partial<Environment$1>;
+type Init$1<T extends TypesGeneric$1 = Types$2> = {
+    code: Instance$1<T>;
+    config?: Partial<Config$4<T>>;
+    env?: Partial<Env$1<T>>;
 };
 interface InitDestinations {
-    [key: string]: Init$1<any, any>;
+    [key: string]: Init$1<any>;
 }
 interface Destinations {
     [key: string]: Instance$1;
 }
-interface Context$1<Settings = unknown, Mapping = unknown> {
+interface Context$2<T extends TypesGeneric$1 = Types$2> {
     collector: Instance$2;
-    config: Config$3<Settings, Mapping>;
+    config: Config$4<T>;
     data?: Data$1;
-    env: Environment$1;
+    env: Env$1<T>;
 }
-interface PushContext<Settings = unknown, Mapping = unknown> extends Context$1<Settings, Mapping> {
-    mapping?: Rule<Mapping>;
+interface PushContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
+    mapping?: Rule<Mapping$1<T>>;
 }
-interface PushBatchContext<Settings = unknown, Mapping = unknown> extends Context$1<Settings, Mapping> {
-    mapping?: Rule<Mapping>;
+interface PushBatchContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
+    mapping?: Rule<Mapping$1<T>>;
 }
-type InitFn<Settings, Mapping> = (context: Context$1<Settings, Mapping>) => PromiseOrValue<void | false | Config$3<Settings, Mapping>>;
-type PushFn<Settings, Mapping> = (event: Event, context: PushContext<Settings, Mapping>) => PromiseOrValue<void>;
-type PushBatchFn<Settings, Mapping> = (batch: Batch<Mapping>, context: PushBatchContext<Settings, Mapping>) => void;
+type InitFn<T extends TypesGeneric$1 = Types$2> = (context: Context$2<T>) => PromiseOrValue<void | false | Config$4<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>;
@@ -201,7 +282,7 @@ type Ref = {
     id: string;
     destination: Instance$1;
 };
-type Push = {
+type Push$1 = {
     queue?: Events;
     error?: unknown;
 };
@@ -211,38 +292,21 @@ type Result$1 = {
     queued: Array<Ref>;
     failed: Array<Ref>;
 };
-/**
- * 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 Environment$1 {
-    /**
-     * Generic global properties that destinations may require
-     * Platform-specific implementations can extend this interface
-     */
-    [key: string]: unknown;
-}
 
 type destination_Batch<Mapping> = Batch<Mapping>;
 type destination_DLQ = DLQ;
 type destination_Destinations = Destinations;
 type destination_InitDestinations = InitDestinations;
-type destination_InitFn<Settings, Mapping> = InitFn<Settings, Mapping>;
-type destination_PartialConfig<Settings = unknown, Mapping = unknown> = PartialConfig<Settings, Mapping>;
-type destination_Policy = Policy;
-type destination_Push = Push;
-type destination_PushBatchContext<Settings = unknown, Mapping = unknown> = PushBatchContext<Settings, Mapping>;
-type destination_PushBatchFn<Settings, Mapping> = PushBatchFn<Settings, Mapping>;
-type destination_PushContext<Settings = unknown, Mapping = unknown> = PushContext<Settings, Mapping>;
+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<Settings, Mapping> = PushFn<Settings, Mapping>;
+type destination_PushFn<T extends TypesGeneric$1 = Types$2> = PushFn<T>;
 type destination_Ref = Ref;
 declare namespace destination {
-  export type { destination_Batch as Batch, Config$3 as Config, Context$1 as Context, destination_DLQ as DLQ, Data$1 as Data, destination_Destinations as Destinations, Environment$1 as Environment, Init$1 as Init, destination_InitDestinations as InitDestinations, destination_InitFn as InitFn, Instance$1 as Instance, destination_PartialConfig as PartialConfig, destination_Policy as Policy, destination_Push 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 };
+  export type { BaseEnv$1 as BaseEnv, destination_Batch as Batch, Config$4 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_InitDestinations as InitDestinations, destination_InitFn as InitFn, Instance$1 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>> {
@@ -255,9 +319,9 @@ interface Fn$1<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, Wa
 interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
     (event: 'walker config', config: Partial<Config>): R;
     (event: 'walker consent', consent: Consent): R;
-    <S, M>(event: 'walker destination', destination: Init$1<S, M> | Instance$1<S, M>, config?: Config$3<S, M>): R;
+    <T extends Types$2>(event: 'walker destination', destination: Init$1<T> | Instance$1<T>, config?: Config$4<T>): R;
     <K extends keyof Functions>(event: 'walker hook', name: K, hookFn: Functions[K]): R;
-    (event: 'walker on', type: Types, rules: SingleOrArray<Options>): R;
+    (event: 'walker on', type: Types$1, rules: SingleOrArray<Options>): R;
     (event: 'walker user', user: User): R;
     (event: 'walker run', runState: {
         consent?: Consent;
@@ -287,15 +351,15 @@ declare namespace elb {
  * Flow configuration interface for dynamic walkerOS setup
  * Used by bundlers and other tools to configure walkerOS dynamically
  */
-interface Config$2 {
+interface Config$3 {
     /** Collector configuration - uses existing Collector.Config from core */
-    collector: Config$4;
+    collector: Config$5;
     /** NPM packages required for this configuration */
     packages: Record<string, string>;
 }
 
 declare namespace flow {
-  export type { Config$2 as Config };
+  export type { Config$3 as Config };
 }
 
 type Error = (error: unknown, state?: unknown) => void;
@@ -323,6 +387,19 @@ declare namespace hooks {
   export type { AnyFunction$1 as AnyFunction, hooks_Functions as Functions, hooks_HookFn as HookFn };
 }
 
+/**
+ * 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;
 }
@@ -336,6 +413,7 @@ interface Rule<Settings = unknown> {
     data?: Data;
     ignore?: boolean;
     name?: string;
+    policy?: Policy;
 }
 interface Result {
     eventMapping?: Rule;
@@ -374,6 +452,7 @@ 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>;
@@ -383,7 +462,7 @@ type mapping_ValueConfig = ValueConfig;
 type mapping_ValueType = ValueType;
 type mapping_Values = Values;
 declare namespace mapping {
-  export type { mapping_Condition as Condition, mapping_Data as Data, mapping_Fn as Fn, mapping_Loop as Loop, mapping_Map as Map, Options$1 as Options, 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$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 = {
@@ -392,7 +471,19 @@ type Config$1 = {
     run?: Array<RunConfig>;
     session?: Array<SessionConfig>;
 };
-type Types = keyof Config$1;
+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;
@@ -411,10 +502,17 @@ interface OnConfig {
     session?: SessionConfig[];
     [key: string]: ConsentConfig[] | ReadyConfig[] | RunConfig[] | SessionConfig[] | undefined;
 }
+type OnFn = <T extends Types$1>(event: T, context: EventContextMap[T]) => PromiseOrValue<void>;
+type OnFnRuntime = (event: Types$1, context: AnyEventContext) => 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 = OnFn;
+type on_OnFnRuntime = OnFnRuntime;
 type on_Options = Options;
 type on_ReadyConfig = ReadyConfig;
 type on_ReadyFn = ReadyFn;
@@ -422,9 +520,8 @@ type on_RunConfig = RunConfig;
 type on_RunFn = RunFn;
 type on_SessionConfig = SessionConfig;
 type on_SessionFn = SessionFn;
-type on_Types = Types;
 declare namespace on {
-  export type { Config$1 as Config, on_ConsentConfig as ConsentConfig, on_ConsentFn as ConsentFn, on_OnConfig as OnConfig, 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, on_Types as Types };
+  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 {
@@ -473,55 +570,76 @@ declare namespace schema {
   export type { schema_Contract as Contract, schema_Contracts as Contracts, Properties$1 as Properties, Property$1 as Property };
 }
 
-interface Config {
-    id?: string;
-    disabled?: boolean;
-    settings: AnyObject;
-    onError?: AnyFunction;
-}
-type InitConfig = Partial<Config>;
 /**
- * Environment interface for dependency injection into sources.
+ * 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 Environment {
-    elb: Fn$1;
+interface BaseEnv {
     [key: string]: unknown;
+    push: PushFn$1;
+    command: CommandFn;
+    sources?: Sources;
+    elb: Fn$1;
 }
 /**
- * Source instance returned by Source.Init function.
+ * Type bundle for source generics.
+ * Groups Settings, Mapping, Push, and Env into a single type parameter.
  *
- * Sources are stateless and contain no collector references.
- * All communication with collector happens via env.elb function.
+ * @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
  */
-interface Instance<T extends Config = Config> {
-    type: string;
-    config: T;
-    push: Fn$1;
-    destroy?(): void | Promise<void>;
-    on?(event: Types, context?: unknown): void | Promise<void>;
+interface Types<S = unknown, M = unknown, P = Fn$1, E = BaseEnv> {
+    settings: S;
+    mapping: M;
+    push: P;
+    env: E;
 }
 /**
- * Source initialization function signature.
- *
- * Sources are functions that receive configuration and environment dependencies
- * and return a stateless instance.
- *
- * @param config - Source configuration (settings, type, etc.)
- * @param env - Environment with elb function and platform APIs (defaults to {})
- * @returns Source instance or promise of instance
+ * Generic constraint for Types - ensures T has required properties for indexed access
+ */
+type TypesGeneric = {
+    settings: any;
+    mapping: any;
+    push: any;
+    env: any;
+};
+/**
+ * Type extractors for consistent usage with Types bundle
  */
-type Init<T extends Config = Config> = (config: Partial<T>, env?: Environment) => Instance<T> | Promise<Instance<T>>;
+type Settings<T extends TypesGeneric = Types> = T['settings'];
+type Mapping<T extends TypesGeneric = Types> = T['mapping'];
+type Push<T extends TypesGeneric = Types> = T['push'];
+type Env<T extends TypesGeneric = Types> = T['env'];
 /**
- * Source configuration interface for collector initialization.
- * Similar to destinations, this defines the structure for source definitions.
+ * Inference helper: Extract Types from Instance
  */
-type InitSource<T extends Config = Config> = {
+type TypesOf<I> = I extends Instance<infer T> ? T : never;
+interface Config<T extends TypesGeneric = Types> extends Config$2<Mapping<T>> {
+    settings?: Settings<T>;
+    env?: Env<T>;
+    id?: string;
+    onError?: Error;
+    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?: T;
-    env?: Partial<Environment>;
+    config?: Partial<Config<T>>;
+    env?: Partial<Env<T>>;
+    primary?: boolean;
 };
 /**
  * Sources configuration for collector.
@@ -531,15 +649,22 @@ interface InitSources {
     [sourceId: string]: InitSource<any>;
 }
 
-type source_Config = Config;
-type source_Environment = Environment;
-type source_Init<T extends Config = Config> = Init<T>;
-type source_InitConfig = InitConfig;
-type source_InitSource<T extends Config = Config> = InitSource<T>;
+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_InitSource<T extends TypesGeneric = Types> = InitSource<T>;
 type source_InitSources = InitSources;
-type source_Instance<T extends Config = Config> = Instance<T>;
+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> = Types<S, M, P, E>;
+type source_TypesGeneric = TypesGeneric;
+type source_TypesOf<I> = TypesOf<I>;
 declare namespace source {
-  export type { source_Config as Config, source_Environment as Environment, source_Init as Init, source_InitConfig as InitConfig, source_InitSource as InitSource, source_InitSources as InitSources, source_Instance as Instance };
+  export type { source_BaseEnv as BaseEnv, source_Config as Config, source_Env as Env, source_Init as Init, 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>;
@@ -668,6 +793,210 @@ declare const Const: {
     };
 };
 
+type SendDataValue = Property | Properties;
+type SendHeaders = {
+    [key: string]: string;
+};
+interface SendResponse {
+    ok: boolean;
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Zod Schemas for walkerOS Mapping ValueConfig
+ *
+ * These schemas provide:
+ * 1. Runtime validation for mapping values
+ * 2. JSON Schema generation for RJSF/Explorer
+ * 3. Documentation via .describe()
+ *
+ * Note: TypeScript types remain in packages/core/src/types/mapping.ts
+ * These Zod schemas are for VALIDATION and JSON SCHEMA GENERATION only.
+ *
+ * The circular/recursive nature of Value → ValueConfig → Value makes
+ * full type inference complex, so we use z.any() with lazy evaluation
+ * and keep existing TypeScript types separate.
+ *
+ * @example
+ * // Validate at runtime
+ * const result = ValueConfigSchema.safeParse(userInput);
+ *
+ * // Generate JSON Schema for Explorer
+ * const jsonSchema = zodToJsonSchema(ValueConfigSchema);
+ */
+/**
+ * Consent schema
+ * Maps consent groups to boolean states
+ */
+declare const ConsentSchema: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+declare const ValueSchema: z.ZodType<any, z.ZodTypeDef, any>;
+declare const LoopSchema: z.ZodType<any, z.ZodTypeDef, any>;
+declare const SetSchema: z.ZodType<any, z.ZodTypeDef, any>;
+declare const MapSchema: z.ZodType<any, z.ZodTypeDef, any>;
+declare const ValueConfigSchema: z.ZodType<any, z.ZodTypeDef, any>;
+declare const valueConfigJsonSchema: zod_to_json_schema.JsonSchema7Type & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: zod_to_json_schema.JsonSchema7Type;
+    } | undefined;
+};
+declare const loopJsonSchema: zod_to_json_schema.JsonSchema7Type & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: zod_to_json_schema.JsonSchema7Type;
+    } | undefined;
+};
+declare const setJsonSchema: zod_to_json_schema.JsonSchema7Type & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: zod_to_json_schema.JsonSchema7Type;
+    } | undefined;
+};
+declare const mapJsonSchema: zod_to_json_schema.JsonSchema7Type & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: zod_to_json_schema.JsonSchema7Type;
+    } | undefined;
+};
+
+/**
+ * JSON Schema type
+ */
+type JSONSchema = Record<string, unknown>;
+/**
+ * Schema Builder - DRY utility for creating JSON Schemas
+ *
+ * This utility allows destinations to define schemas using simple objects,
+ * without needing Zod as a dependency. The core package handles conversion.
+ *
+ * Benefits:
+ * - Single source of schema generation logic
+ * - No Zod dependency in destination packages
+ * - Simple, declarative schema definitions
+ * - Type-safe with TypeScript
+ * - Follows DRY principle
+ *
+ * @example
+ * // In destination package (NO Zod needed!)
+ * import { createObjectSchema, createArraySchema } from '@walkeros/core/schemas';
+ *
+ * export const settingsSchema = createObjectSchema({
+ *   pixelId: {
+ *     type: 'string',
+ *     required: true,
+ *     pattern: '^[0-9]+$',
+ *     description: 'Your Meta Pixel ID',
+ *   },
+ * });
+ */
+/**
+ * Property definition for schema builder
+ */
+interface PropertyDef {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required?: boolean;
+    description?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    enum?: readonly string[] | readonly number[];
+    properties?: Record<string, PropertyDef>;
+    items?: PropertyDef;
+    default?: unknown;
+}
+/**
+ * Create object schema from property definitions
+ *
+ * @param properties - Property definitions
+ * @param title - Optional schema title
+ * @returns JSON Schema
+ *
+ * @example
+ * const schema = createObjectSchema({
+ *   pixelId: {
+ *     type: 'string',
+ *     required: true,
+ *     pattern: '^[0-9]+$',
+ *     description: 'Your Meta Pixel ID',
+ *   },
+ *   eventName: {
+ *     type: 'string',
+ *     enum: ['PageView', 'Purchase'],
+ *   },
+ * }, 'Meta Pixel Settings');
+ */
+declare function createObjectSchema(properties: Record<string, PropertyDef>, title?: string): JSONSchema;
+/**
+ * Create array schema
+ *
+ * @param itemDef - Definition for array items
+ * @param options - Optional array constraints
+ * @returns JSON Schema
+ *
+ * @example
+ * // Simple string array
+ * const tagsSchema = createArraySchema({ type: 'string' });
+ *
+ * // Tuple (loop pattern) - exactly 2 items
+ * const loopSchema = createArraySchema(
+ *   { type: 'object' },
+ *   { minItems: 2, maxItems: 2 }
+ * );
+ *
+ * // Array with enum
+ * const includeSchema = createArraySchema({
+ *   type: 'string',
+ *   enum: ['data', 'context', 'globals'],
+ * });
+ */
+declare function createArraySchema(itemDef: PropertyDef, options?: {
+    minItems?: number;
+    maxItems?: number;
+    description?: string;
+    title?: string;
+}): JSONSchema;
+/**
+ * Create enum schema
+ *
+ * @param values - Allowed values
+ * @param type - Value type ('string' or 'number')
+ * @param options - Optional constraints
+ * @returns JSON Schema
+ *
+ * @example
+ * const eventTypeSchema = createEnumSchema(
+ *   ['PageView', 'Purchase', 'AddToCart'],
+ *   'string',
+ *   { description: 'Meta Pixel standard event' }
+ * );
+ */
+declare function createEnumSchema(values: readonly string[] | readonly number[], type?: 'string' | 'number', options?: {
+    description?: string;
+    title?: string;
+}): JSONSchema;
+/**
+ * Create tuple schema (Loop pattern)
+ *
+ * Creates an array schema with exactly 2 items, which the Explorer
+ * type detector recognizes as a "loop" pattern.
+ *
+ * @param firstItem - Definition for first element (source)
+ * @param secondItem - Definition for second element (transform)
+ * @param description - Optional description
+ * @returns JSON Schema with minItems=2, maxItems=2
+ *
+ * @example
+ * const loopSchema = createTupleSchema(
+ *   { type: 'string' },
+ *   { type: 'object' },
+ *   'Loop: [source, transform]'
+ * );
+ */
+declare function createTupleSchema(firstItem: PropertyDef, secondItem: PropertyDef, description?: string): JSONSchema;
+
 /**
  * Anonymizes an IPv4 address by setting the last octet to 0.
  *
@@ -715,12 +1044,12 @@ declare function getByPath(event: unknown, key?: string, defaultValue?: unknown)
 /**
  * Sets a value in an object by a dot-notation string.
  *
- * @param event - The object to set the value in.
+ * @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(event: Event, key: string, value: unknown): Event;
+declare function setByPath<T = unknown>(obj: T, key: string, value: unknown): T;
 
 /**
  * Casts a value to a specific type.
@@ -758,26 +1087,19 @@ declare function getGrantedConsent(required: Consent | undefined, state?: Consen
  * This utility enables elegant destination configuration while avoiding config side-effects
  * that could occur when reusing destination objects across multiple collector instances.
  *
- * @template Settings - The destination settings type
- * @template Mapping - The destination mapping type
  * @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
- * // Instead of:
- * elb('walker destination', destinationGtag, {
- *   settings: { ga4: { measurementId: 'G-123' } }
- * });
- *
- * // You can use:
+ * // Types are inferred automatically from destinationGtag
  * elb('walker destination', createDestination(destinationGtag, {
  *   settings: { ga4: { measurementId: 'G-123' } }
  * }));
  * ```
  */
-declare function createDestination<Settings = unknown, Mapping = unknown>(baseDestination: Instance$1<Settings, Mapping>, config: Partial<Config$3<Settings, Mapping>>): Instance$1<Settings, Mapping>;
+declare function createDestination<I extends Instance$1>(baseDestination: I, config: Partial<Config$4<TypesOf$1<I>>>): I;
 
 /**
  * Creates a complete event with default values.
@@ -914,11 +1236,11 @@ declare function isString(value: unknown): value is string;
 /**
  * Gets the mapping for an event.
  *
- * @param event The event to get the mapping for.
+ * @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: PartialEvent, mapping?: Rules): Promise<Result>;
+declare function getMappingEvent(event: DeepPartialEvent | PartialEvent | Event, mapping?: Rules): Promise<Result>;
 /**
  * Gets a value from a mapping.
  *
@@ -928,6 +1250,98 @@ declare function getMappingEvent(event: PartialEvent, mapping?: Rules): Promise<
  * @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$2): 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;
 
 /**
  * Logs a message to the console if verbose logging is enabled.
@@ -974,15 +1388,6 @@ declare function requestToData(parameter: unknown): AnyObject | undefined;
  */
 declare function requestToParameter(data: AnyObject | PropertyType): string;
 
-type SendDataValue = Property | Properties;
-type SendHeaders = {
-    [key: string]: string;
-};
-interface SendResponse {
-    ok: boolean;
-    data?: unknown;
-    error?: string;
-}
 /**
  * Transforms data to a string.
  *
@@ -1109,4 +1514,4 @@ declare function validateEvent(obj: unknown, customContracts?: Contracts): Event
  */
 declare function validateProperty(obj: AnyObject, key: string, value: unknown, schema: Property$1): Property | never;
 
-export { collector as Collector, Const, data as Data, destination as Destination, elb as Elb, flow as Flow, handler as Handler, hooks as Hooks, mapping as Mapping, type MarketingParameters, 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, debounce, filterValues, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isSameType, isString, onLog, parseUserAgent, requestToData, requestToParameter, setByPath, throttle, throwError, transformData, trim, tryCatch, tryCatchAsync, useHooks, validateEvent, validateProperty };
+export { collector as Collector, ConsentSchema, Const, data as Data, destination as Destination, elb as Elb, flow as Flow, handler as Handler, hooks as Hooks, type JSONSchema, LoopSchema, MapSchema, mapping as Mapping, type MarketingParameters, on as On, type PropertyDef, request as Request, schema as Schema, type SendDataValue, type SendHeaders, type SendResponse, SetSchema, source as Source, type StorageType, ValueConfigSchema, ValueSchema, walkeros as WalkerOS, anonymizeIP, assign, castToProperty, castValue, clone, createArraySchema, createDestination, createEnumSchema, createEvent, createObjectSchema, createTupleSchema, debounce, filterValues, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isSameType, isString, loopJsonSchema, mapJsonSchema, mockEnv, onLog, parseUserAgent, processEventMapping, requestToData, requestToParameter, setByPath, setJsonSchema, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateEvent, validateProperty, valueConfigJsonSchema };