@walkeros/core 0.2.0 → 0.2.1

package/dist/index.d.mts

@@ -1,7 +1,10 @@
+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;
     /** Version for event tagging */
@@ -20,7 +23,7 @@ interface Config$4 {
 /**
  * Initialization configuration that extends Config with initial state
  */
-interface InitConfig extends Partial<Config$4> {
+interface InitConfig extends Partial<Config$5> {
     /** Initial consent state */
     consent?: Consent;
     /** Initial user data */
@@ -53,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;
@@ -74,12 +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, collector_InitConfig 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 {
@@ -176,7 +211,7 @@ type Env$1<T extends TypesGeneric$1 = Types$2> = T['env'];
  */
 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>;
+    config: Config$4<T>;
     queue?: Events;
     dlq?: DLQ;
     type?: string;
@@ -186,7 +221,7 @@ interface Instance$1<T extends TypesGeneric$1 = Types$2> {
     pushBatch?: PushBatchFn<T>;
     on?: OnFn;
 }
-interface Config$3<T extends TypesGeneric$1 = Types$2> {
+interface Config$4<T extends TypesGeneric$1 = Types$2> {
     consent?: Consent;
     settings?: Settings$1<T>;
     data?: Value | Values;
@@ -201,13 +236,13 @@ interface Config$3<T extends TypesGeneric$1 = Types$2> {
     onError?: Error;
     onLog?: Log;
 }
-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>>>;
+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<T extends TypesGeneric$1 = Types$2> = {
     code: Instance$1<T>;
-    config?: Partial<Config$3<T>>;
+    config?: Partial<Config$4<T>>;
     env?: Partial<Env$1<T>>;
 };
 interface InitDestinations {
@@ -218,7 +253,7 @@ interface Destinations {
 }
 interface Context$2<T extends TypesGeneric$1 = Types$2> {
     collector: Instance$2;
-    config: Config$3<T>;
+    config: Config$4<T>;
     data?: Data$1;
     env: Env$1<T>;
 }
@@ -228,7 +263,7 @@ interface PushContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
 interface PushBatchContext<T extends TypesGeneric$1 = Types$2> extends Context$2<T> {
     mapping?: Rule<Mapping$1<T>>;
 }
-type InitFn<T extends TypesGeneric$1 = Types$2> = (context: Context$2<T>) => PromiseOrValue<void | false | Config$3<T>>;
+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> = {
@@ -271,7 +306,7 @@ type destination_PushEvents<Mapping = unknown> = PushEvents<Mapping>;
 type destination_PushFn<T extends TypesGeneric$1 = Types$2> = PushFn<T>;
 type destination_Ref = Ref;
 declare namespace destination {
-  export type { BaseEnv$1 as BaseEnv, destination_Batch as Batch, 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 };
+  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>> {
@@ -284,7 +319,7 @@ 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;
-    <T extends Types$2>(event: 'walker destination', destination: Init$1<T> | Instance$1<T>, config?: Config$3<T>): 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$1, rules: SingleOrArray<Options>): R;
     (event: 'walker user', user: User): R;
@@ -316,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;
@@ -352,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;
 }
@@ -365,6 +413,7 @@ interface Rule<Settings = unknown> {
     data?: Data;
     ignore?: boolean;
     name?: string;
+    policy?: Policy;
 }
 interface Result {
     eventMapping?: Rule;
@@ -403,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>;
@@ -412,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 = {
@@ -527,8 +577,11 @@ declare namespace schema {
  * making them platform-agnostic and easily testable.
  */
 interface BaseEnv {
-    elb: Fn$1;
     [key: string]: unknown;
+    push: PushFn$1;
+    command: CommandFn;
+    sources?: Sources;
+    elb: Fn$1;
 }
 /**
  * Type bundle for source generics.
@@ -565,7 +618,7 @@ 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> {
+interface Config<T extends TypesGeneric = Types> extends Config$2<Mapping<T>> {
     settings?: Settings<T>;
     env?: Env<T>;
     id?: string;
@@ -574,9 +627,6 @@ interface Config<T extends TypesGeneric = Types> {
     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>;
@@ -608,14 +658,13 @@ type source_InitSources = InitSources;
 type source_Instance<T extends TypesGeneric = Types> = Instance<T>;
 type source_Mapping<T extends TypesGeneric = Types> = Mapping<T>;
 type source_PartialConfig<T extends TypesGeneric = Types> = PartialConfig<T>;
-type source_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_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 };
+  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>;
@@ -744,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.
  *
@@ -791,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.
@@ -846,7 +1099,7 @@ declare function getGrantedConsent(required: Consent | undefined, state?: Consen
  * }));
  * ```
  */
-declare function createDestination<I extends Instance$1>(baseDestination: I, config: Partial<Config$3<TypesOf$1<I>>>): I;
+declare function createDestination<I extends Instance$1>(baseDestination: I, config: Partial<Config$4<TypesOf$1<I>>>): I;
 
 /**
  * Creates a complete event with default values.
@@ -983,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.
  *
@@ -997,6 +1250,32 @@ 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
@@ -1109,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.
  *
@@ -1244,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, mockEnv, onLog, parseUserAgent, requestToData, requestToParameter, setByPath, throttle, throwError, transformData, traverseEnv, 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 };