@walkeros/core 0.1.1 → 0.2.0

package/dist/index.d.mts

@@ -4,24 +4,12 @@
 interface Config$4 {
     /** 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 +17,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$4> {
+    /** 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;
@@ -71,10 +75,11 @@ interface Instance$2 {
 }
 
 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_CommandType as CommandType, Config$4 as Config, Destinations$1 as Destinations, collector_InitConfig as InitConfig, Instance$2 as Instance, collector_SessionData as SessionData, collector_Sources as Sources };
 }
 
 interface Contract$1 {
@@ -87,7 +92,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 +102,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 +131,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$3<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$3<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$3<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$3<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$3<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$3<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 +247,7 @@ type Ref = {
     id: string;
     destination: Instance$1;
 };
-type Push = {
+type Push$1 = {
     queue?: Events;
     error?: unknown;
 };
@@ -211,38 +257,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$3 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 +284,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;
-    (event: 'walker destination', destination: Init$1 | Instance$1, config?: Config$3): R;
+    <T extends Types$2>(event: 'walker destination', destination: Init$1<T> | Instance$1<T>, config?: Config$3<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;
@@ -273,18 +302,14 @@ interface PushResult extends Result$1 {
     ok: boolean;
 }
 type Layer = Array<IArguments | DeepPartialEvent | unknown[]>;
-interface RegisterDestination<Destination, Config> {
-    (event: 'walker destination', destination: Destination, config?: Config): Promise<PushResult>;
-}
 
 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_RegisterDestination<Destination, Config> = RegisterDestination<Destination, Config>;
 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_RegisterDestination as RegisterDestination, elb_WalkerCommands as WalkerCommands };
+  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 };
 }
 
 /**
@@ -396,7 +421,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;
@@ -415,10 +452,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;
@@ -426,9 +470,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 {
@@ -477,55 +520,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 {
+interface BaseEnv {
     elb: Fn$1;
     [key: string]: unknown;
 }
 /**
- * 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> {
+    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 Policy {
+    [key: string]: Value;
+}
+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.
@@ -535,27 +599,29 @@ 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_Policy = Policy;
+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_Policy as Policy, 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 = globalThis.WalkerOS.Elb;
+type Elb = Fn$1;
 type AnyFunction = (...args: unknown[]) => unknown;
 type SingleOrArray<T> = T | Array<T>;
-declare global {
-    namespace WalkerOS {
-        interface Elb extends Fn$1 {
-        }
-    }
-}
 type Events = Array<Event>;
 type PartialEvent = Partial<Event>;
 type DeepPartialEvent = DeepPartial<Event>;
@@ -768,26 +834,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$3<TypesOf$1<I>>>): I;
 
 /**
  * Creates a complete event with default values.
@@ -939,6 +998,72 @@ declare function getMappingEvent(event: PartialEvent, mapping?: Rules): Promise<
  */
 declare function getMappingValue(value: DeepPartialEvent | unknown | undefined, data?: Data, options?: Options$1): Promise<Property | undefined>;
 
+/**
+ * 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.
  *
@@ -1119,4 +1244,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, 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, mockEnv, onLog, parseUserAgent, requestToData, requestToParameter, setByPath, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateEvent, validateProperty };