@walkeros/core 0.0.7 → 0.1.0

package/README.md

@@ -1,108 +1,313 @@
 <p align="left">
   <a href="https://elbwalker.com">
-    <img title="elbwalker" src='https://www.elbwalker.com/img/elbwalker_logo.png' width="256px"/>
+    <img title="elbwalker" src="https://www.elbwalker.com/img/elbwalker_logo.png" width="256px"/>
   </a>
 </p>
 
 # Core Types & Utilities for walkerOS
 
-The walkerOS Core package provides the foundational TypeScript definitions and
-platform-agnostic utilities that power the entire walkerOS ecosystem. It serves
-as the bedrock for type safety and shared functionality across all sources,
-collectors, and destinations.
+[Source Code](https://github.com/elbwalker/walkerOS/tree/main/packages/core)
+&bull; [NPM Package](https://www.npmjs.com/package/@walkeros/core)
 
-## Role in walkerOS Ecosystem
+Core utilities are a collection of platform-agnostic functions that can be used
+across all walkerOS environments. They provide standardized building blocks for
+data manipulation, validation, mapping, and more.
 
-walkerOS follows a **source → collector → destination** architecture:
+## Installation
 
-- **Sources**: Capture events from various environments (browser DOM, dataLayer,
-  server requests)
-- **Collector**: Processes, validates, and routes events with consent awareness
-- **Destinations**: Send processed events to analytics platforms (GA4, Meta,
-  custom APIs)
+Import the core utilities directly from the `@walkeros/core` package:
 
-The Core package provides the essential building blocks that all other packages
-depend on, ensuring consistent data structures, type definitions, and utility
-functions across the entire platform.
+```ts
+import { assign, anonymizeIP, getMappingValue } from '@walkeros/core';
+```
 
-## Installation
+## Core Utilities
+
+### Data Manipulation
+
+#### assign
+
+`assign<T, U>(target: T, source: U, options?): T & U` merges two objects with
+advanced merging capabilities. It has special behavior for arrays: when merging,
+it concatenates arrays from both objects, removing duplicates.
+
+```ts
+interface AssignOptions {
+  merge?: boolean; // Merge array properties (default: true)
+  shallow?: boolean; // Create shallow copy (default: true)
+  extend?: boolean; // Extend with new properties (default: true)
+}
+
+const obj1 = { a: 1, b: [1, 2] };
+const obj2 = { b: [2, 3], c: 3 };
+
+assign(obj1, obj2); // Returns { a: 1, b: [1, 2, 3], c: 3 }
+assign(obj1, obj2, { merge: false }); // Returns { a: 1, b: [2, 3], c: 3 }
+```
+
+#### Path Operations
+
+##### getByPath
+
+`getByPath(object: unknown, path: string, defaultValue?: unknown): unknown`
+accesses nested properties using dot notation. Supports wildcard `*` for array
+iteration.
+
+```js
+getByPath({ data: { id: 'wow' } }, 'data.id'); // Returns "wow"
+getByPath({ nested: [1, 2, { id: 'cool' }] }, 'nested.*.id'); // Returns ['', '', 'cool']
+getByPath({ arr: ['foo', 'bar'] }, 'arr.1'); // Returns "bar"
+```
+
+##### setByPath
+
+`setByPath(object: WalkerOS.Event, path: string, value: unknown): WalkerOS.Event`
+sets nested values using dot notation, returning a new object with the updated
+value.
+
+```js
+const updatedEvent = setByPath(event, 'data.id', 'new-value');
+// Returns a new event with data.id set to 'new-value'
+```
+
+#### clone
+
+`clone<T>(original: T): T` creates a deep copy of objects/arrays with circular
+reference handling.
 
-```sh
-npm install @walkeros/core
+```js
+const original = { foo: true, arr: ['a', 'b'] };
+const cloned = clone(original);
+original.foo = false; // cloned.foo remains true
 ```
 
-## Usage
+#### castValue
 
-The core package exports essential types and utilities:
+`castValue(value: unknown): WalkerOS.PropertyType` converts string values to
+appropriate types (number, boolean).
 
-```typescript
-import {
-  // Core event types
-  WalkerOS,
+```js
+castValue('123'); // Returns 123 (number)
+castValue('true'); // Returns true (boolean)
+castValue('hello'); // Returns 'hello' (unchanged)
+```
+
+### Privacy & Security
+
+#### anonymizeIP
+
+`anonymizeIP(ip: string): string` anonymizes IPv4 addresses by setting the last
+oclet to zero.
+
+```js
+anonymizeIP('192.168.1.100'); // Returns '192.168.1.0'
+```
+
+#### Hashing
+
+`getId(length?: number): string` generates random alphanumeric strings for
+unique identifiers.
+
+```js
+getId(); // Returns random 6-char string like 'a1b2c3'
+getId(10); // Returns 10-character string
+```
+
+### Event Processing
 
-  // Utility functions
-  assign,
-  clone,
-  validateEvent,
+#### getMappingValue
 
-  // Consent management
-  Consent,
+`getMappingValue(event: WalkerOS.Event, mapping: Mapping.Data, options?: Mapping.Options): Promise<WalkerOS.Property | undefined>`
+extracts values from events using
+[mapping configurations](https://www.elbwalker.com/docs/destinations/event-mapping).
 
-  // Mapping utilities
-  byPath,
-  mapping,
-} from '@walkeros/core';
+```ts
+// Simple path mapping
+await getMappingValue(event, 'data.productId');
 
-// Example: Validate an event
-const event: WalkerOS.Event = {
-  event: 'order complete',
-  data: { value: 9001 },
-  // ... other properties
+// Complex mapping with conditions and loops
+const mapping = {
+  map: {
+    orderId: 'data.id',
+    products: {
+      loop: [
+        'nested',
+        {
+          condition: (entity) => entity.entity === 'product',
+          map: { id: 'data.id', name: 'data.name' },
+        },
+      ],
+    },
+  },
 };
+await getMappingValue(event, mapping);
+```
 
-if (validateEvent(event)) {
-  console.log('Event is valid!');
-}
+#### getMappingEvent
+
+`getMappingEvent(event: WalkerOS.PartialEvent, mapping?: Mapping.Rules): Promise<Mapping.Result>`
+finds the appropriate mapping rule for an event.
+
+### Marketing & Analytics
+
+#### getMarketingParameters
+
+`getMarketingParameters(url: URL, custom?: MarketingParameters): WalkerOS.Properties`
+extracts UTM and click ID parameters from URLs.
+
+```js
+getMarketingParameters(
+  new URL('https://example.com/?utm_source=docs&gclid=123'),
+);
+// Returns { source: "docs", gclid: "123", clickId: "gclid" }
+
+// With custom parameters
+getMarketingParameters(url, { utm_custom: 'custom', partner: 'partnerId' });
 ```
 
-## Event Naming Convention
+### Type Validation
+
+#### Type Checkers
+
+A comprehensive set of type checking functions:
+
+- `isString(value)`, `isNumber(value)`, `isBoolean(value)`
+- `isArray(value)`, `isObject(value)`, `isFunction(value)`
+- `isDefined(value)`, `isSameType(a, b)`
+- `isPropertyType(value)` - Checks if value is valid walkerOS property
 
-walkerOS follows a strict **"entity action"** naming convention for events:
+#### Property Utilities
 
-✅ **Correct**: Use spaces to separate entity and action
+- `castToProperty(value)` - Casts to valid property type
+- `filterValues(object)` - Filters object to valid properties only
+- `isPropertyType(value)` - Type guard for property validation
 
-```typescript
-elb('order complete', { value: 99.99 });
-elb('product add', { id: 'abc123' });
-elb('page view', { path: '/home' });
-elb('user register', { email: 'user@example.com' });
+### Request Handling
+
+#### requestToData
+
+`requestToData(parameter: unknown): WalkerOS.AnyObject | undefined` converts
+query strings to JavaScript objects with type casting.
+
+```js
+requestToData('a=1&b=true&c=hello&arr[0]=x&arr[1]=y');
+// Returns { a: 1, b: true, c: 'hello', arr: ['x', 'y'] }
+```
+
+#### requestToParameter
+
+`requestToParameter(data: WalkerOS.AnyObject): string` converts objects to
+URL-encoded query strings.
+
+```js
+requestToParameter({ a: 1, b: true, arr: ['x', 'y'] });
+// Returns 'a=1&b=true&arr[0]=x&arr[1]=y'
+```
+
+### User Agent Parsing
+
+#### parseUserAgent
+
+`parseUserAgent(userAgent?: string): WalkerOS.User` extracts browser, OS, and
+device information.
+
+```js
+parseUserAgent(navigator.userAgent);
+// Returns { browser: 'Chrome', browserVersion: '91.0', os: 'Windows', ... }
 ```
 
-❌ **Incorrect**: Do not use underscores or other separators
+Individual functions are also available:
+
+- `getBrowser(userAgent)` - Returns browser name
+- `getBrowserVersion(userAgent)` - Returns browser version
+- `getOS(userAgent)` - Returns operating system
+- `getOSVersion(userAgent)` - Returns OS version
+- `getDeviceType(userAgent)` - Returns 'Desktop', 'Tablet', or 'Mobile'
+
+### Error Handling
 
-```typescript
-// Don't do this
-elb('order_complete', data); // Wrong: underscores
-elb('orderComplete', data); // Wrong: camelCase
-elb('purchase', data); // Wrong: single word
+#### tryCatch
+
+`tryCatch(tryFn: Function, catchFn?: Function, finallyFn?: Function)` wraps
+functions with error handling.
+
+```js
+const safeParse = tryCatch(JSON.parse, () => ({}));
+safeParse('{"valid": "json"}'); // Parses successfully
+safeParse('invalid'); // Returns {} instead of throwing
 ```
 
-**Why spaces matter**: walkerOS destinations automatically transform your
-semantic event names into platform-specific formats. For example,
-`'order complete'` becomes `'purchase'` for Google Analytics 4, while preserving
-the original meaning in your data model.
+#### tryCatchAsync
+
+`tryCatchAsync(tryFn: Function, catchFn?: Function, finallyFn?: Function)` for
+async operations.
+
+```js
+const safeAsyncCall = tryCatchAsync(
+  () => fetchUserData(),
+  (error) => ({ error: 'Failed to load user' }),
+);
+```
+
+### Performance Optimization
+
+#### debounce
+
+`debounce(fn: Function, wait?: number)` delays function execution until after
+the wait time.
+
+```js
+const debouncedSearch = debounce(searchFunction, 300);
+// Only executes after 300ms of inactivity
+```
+
+#### throttle
+
+`throttle(fn: Function, wait?: number)` limits function execution frequency.
+
+```js
+const throttledScroll = throttle(scrollHandler, 100);
+// Executes at most every 100ms
+```
+
+### Utilities
+
+#### trim
+
+`trim(str: string): string` removes whitespace from string ends.
+
+#### throwError
+
+`throwError(message: string)` throws descriptive errors.
+
+#### onLog
+
+`onLog(message: unknown, verbose?: boolean)` provides consistent logging.
+
+```js
+onLog('Debug info', true); // Logs message
+onLog('Silent message'); // No output
+```
+
+### Validation
+
+#### validateEvent
+
+`validateEvent(obj: unknown, customContracts?: Schema.Contracts): WalkerOS.Event | never`
+validates event structure and throws on invalid events.
+
+#### validateProperty
+
+Validates that values conform to walkerOS property types.
+
+---
 
-## Core Features
+For platform-specific utilities, see:
 
-- **TypeScript Definitions**: Complete type system for walkerOS events and
-  configurations
-- **Platform-Agnostic Utilities**: Shared functions for data manipulation and
-  validation
-- **Consent Types**: Standardized consent management interfaces
-- **Event Validation**: Built-in validation for event structure and data
-  integrity
-- **Mapping Utilities**: Tools for transforming data between different formats
-- **Privacy Utilities**: Functions for data anonymization and privacy compliance
+- [Web Core](https://www.elbwalker.com/docs/core/web) - Browser-specific
+  functions
+- [Server Core](https://www.elbwalker.com/docs/core/server) - Node.js server
+  functions
 
 ## Contribute
 

package/dist/index.d.mts

@@ -2,8 +2,6 @@
  * Core collector configuration interface
  */
 interface Config$4 {
-    /** Run in dry mode without executing events */
-    dryRun: boolean;
     /** Whether to run collector automatically */
     run?: boolean;
     /** Initial consent state */
@@ -56,7 +54,7 @@ interface CollectorSource {
 }
 type CommandType = 'action' | 'config' | 'consent' | 'context' | 'destination' | 'elb' | 'globals' | 'hook' | 'init' | 'link' | 'run' | 'user' | 'walker' | string;
 interface Instance$2 {
-    push: Fn$2;
+    push: Fn$1;
     allowed: boolean;
     config: Config$4;
     consent: Consent;
@@ -141,6 +139,7 @@ interface Instance$1<Settings = unknown, Mapping = unknown> {
     queue?: Events;
     dlq?: DLQ;
     type?: string;
+    env?: Environment;
     init?: InitFn<Settings, Mapping>;
     push: PushFn<Settings, Mapping>;
     pushBatch?: PushBatchFn<Settings, Mapping>;
@@ -149,16 +148,15 @@ interface Config$3<Settings = unknown, Mapping = unknown> {
     consent?: Consent;
     settings?: Settings;
     data?: Value | Values;
-    dryRun?: boolean;
+    env?: Environment;
     id?: string;
     init?: boolean;
     loadScript?: boolean;
     mapping?: Rules<Rule<Mapping>>;
-    on?: Config$2;
+    on?: Config$1;
     policy?: Policy;
     queue?: boolean;
     verbose?: boolean;
-    wrapper?: Config;
     onError?: Error;
     onLog?: Log;
 }
@@ -180,7 +178,7 @@ interface Context$1<Settings = unknown, Mapping = unknown> {
     collector: Instance$2;
     config: Config$3<Settings, Mapping>;
     data?: Data$1;
-    wrap: Wrap;
+    env: Environment;
 }
 interface PushContext<Settings = unknown, Mapping = unknown> extends Context$1<Settings, Mapping> {
     mapping?: Rule<Mapping>;
@@ -217,10 +215,25 @@ 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 {
+    /**
+     * 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_Environment = Environment;
 type destination_InitDestination<Settings = unknown, Mapping = unknown> = InitDestination<Settings, Mapping>;
 type destination_InitDestinations = InitDestinations;
 type destination_InitFn<Settings, Mapping> = InitFn<Settings, Mapping>;
@@ -235,7 +248,7 @@ type destination_PushEvents<Mapping = unknown> = PushEvents<Mapping>;
 type destination_PushFn<Settings, Mapping> = PushFn<Settings, Mapping>;
 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, Init$1 as Init, destination_InitDestination as InitDestination, 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 { destination_Batch as Batch, Config$3 as Config, Context$1 as Context, destination_DLQ as DLQ, Data$1 as Data, destination_Destinations as Destinations, destination_Environment as Environment, Init$1 as Init, destination_InitDestination as InitDestination, 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 };
 }
 
 interface EventFn<R = Promise<PushResult>> {
@@ -243,7 +256,7 @@ interface EventFn<R = Promise<PushResult>> {
     (event: string): R;
     (event: string, data: Properties): R;
 }
-interface Fn$2<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
+interface Fn$1<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
 }
 interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
     (event: 'walker config', config: Partial<Config>): R;
@@ -277,7 +290,22 @@ 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$2 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_RegisterDestination as RegisterDestination, elb_WalkerCommands as WalkerCommands };
+}
+
+/**
+ * Flow configuration interface for dynamic walkerOS setup
+ * Used by bundlers and other tools to configure walkerOS dynamically
+ */
+interface Config$2 {
+    /** Collector configuration - uses existing Collector.Config from core */
+    collector: Config$4;
+    /** NPM packages required for this configuration */
+    packages: Record<string, string>;
+}
+
+declare namespace flow {
+  export type { Config$2 as Config };
 }
 
 type Error = (error: unknown, state?: unknown) => void;
@@ -330,7 +358,7 @@ type ValueType = string | ValueConfig;
 interface ValueConfig {
     condition?: Condition;
     consent?: Consent;
-    fn?: Fn$1;
+    fn?: Fn;
     key?: string;
     loop?: Loop;
     map?: Map;
@@ -339,7 +367,7 @@ interface ValueConfig {
     value?: PropertyType;
 }
 type Condition = (value: DeepPartialEvent | unknown, mapping?: Value, collector?: Instance$2) => PromiseOrValue<boolean>;
-type Fn$1 = (value: DeepPartialEvent | unknown, mapping: Value, options: Options$1) => PromiseOrValue<Property | unknown>;
+type Fn = (value: DeepPartialEvent | unknown, mapping: Value, options: Options$1) => PromiseOrValue<Property | unknown>;
 type Loop = [Value, Value];
 type Map = {
     [key: string]: Value;
@@ -353,6 +381,7 @@ type Validate = (value?: unknown) => PromiseOrValue<boolean>;
 
 type mapping_Condition = Condition;
 type mapping_Data = Data;
+type mapping_Fn = Fn;
 type mapping_Loop = Loop;
 type mapping_Map = Map;
 type mapping_Result = Result;
@@ -364,16 +393,16 @@ 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, Fn$1 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, 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 };
 }
 
-type Config$2 = {
+type Config$1 = {
     consent?: Array<ConsentConfig>;
     ready?: Array<ReadyConfig>;
     run?: Array<RunConfig>;
     session?: Array<SessionConfig>;
 };
-type Types = keyof Config$2;
+type Types = keyof Config$1;
 type Options = ConsentConfig | ReadyConfig | RunConfig | SessionConfig;
 interface ConsentConfig {
     [key: string]: ConsentFn;
@@ -405,7 +434,7 @@ type on_SessionConfig = SessionConfig;
 type on_SessionFn = SessionFn;
 type on_Types = Types;
 declare namespace on {
-  export type { Config$2 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 { 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 };
 }
 
 interface Context {
@@ -454,34 +483,35 @@ declare namespace schema {
   export type { schema_Contract as Contract, schema_Contracts as Contracts, Properties$1 as Properties, Property$1 as Property };
 }
 
-interface Config$1 {
+interface Config {
     type: string;
     id?: string;
     disabled?: boolean;
     settings: AnyObject;
     onError?: AnyFunction;
 }
-type InitConfig = Partial<Config$1>;
-interface Init<T extends Config$1 = Config$1, E = AnyFunction> {
+type InitConfig = Partial<Config>;
+interface Init<T extends Config = Config, E = AnyFunction> {
     (collector: Instance$2, config: T): CreateSource<T, E> | Promise<CreateSource<T, E>>;
 }
-interface CreateSource<T extends Config$1 = Config$1, E = AnyFunction> {
+interface CreateSource<T extends Config = Config, E = AnyFunction> {
     source?: Instance<T>;
     elb?: E;
 }
-interface Instance<T extends Config$1 = Config$1> {
+interface Instance<T extends Config = Config> {
     type: string;
     config: T;
     collector: Instance$2;
     destroy?(): void | Promise<void>;
 }
 
-type source_CreateSource<T extends Config$1 = Config$1, E = AnyFunction> = CreateSource<T, E>;
-type source_Init<T extends Config$1 = Config$1, E = AnyFunction> = Init<T, E>;
+type source_Config = Config;
+type source_CreateSource<T extends Config = Config, E = AnyFunction> = CreateSource<T, E>;
+type source_Init<T extends Config = Config, E = AnyFunction> = Init<T, E>;
 type source_InitConfig = InitConfig;
-type source_Instance<T extends Config$1 = Config$1> = Instance<T>;
+type source_Instance<T extends Config = Config> = Instance<T>;
 declare namespace source {
-  export type { Config$1 as Config, source_CreateSource as CreateSource, source_Init as Init, source_InitConfig as InitConfig, source_Instance as Instance };
+  export type { source_Config as Config, source_CreateSource as CreateSource, source_Init as Init, source_InitConfig as InitConfig, source_Instance as Instance };
 }
 
 type AnyObject<T = unknown> = Record<string, T>;
@@ -490,7 +520,7 @@ type AnyFunction = (...args: unknown[]) => unknown;
 type SingleOrArray<T> = T | Array<T>;
 declare global {
     namespace WalkerOS {
-        interface Elb extends Fn$2 {
+        interface Elb extends Fn$1 {
         }
     }
 }
@@ -498,7 +528,7 @@ type Events = Array<Event>;
 type PartialEvent = Partial<Event>;
 type DeepPartialEvent = DeepPartial<Event>;
 interface Event {
-    event: string;
+    name: string;
     data: Properties;
     context: OrderedProperties;
     globals: Properties;
@@ -566,7 +596,7 @@ interface OrderedProperties {
 }
 type Entities = Array<Entity>;
 interface Entity {
-    type: string;
+    entity: string;
     data: Properties;
     nested: Entities;
     context: OrderedProperties;
@@ -605,26 +635,6 @@ declare namespace walkeros {
   export type { walkeros_ActionHandler as ActionHandler, walkeros_AnyFunction as AnyFunction, walkeros_AnyObject as AnyObject, walkeros_Consent as Consent, walkeros_ConsentHandler as ConsentHandler, walkeros_DeepPartial as DeepPartial, walkeros_DeepPartialEvent as DeepPartialEvent, walkeros_Elb as Elb, walkeros_Entities as Entities, walkeros_Entity as Entity, walkeros_Event as Event, walkeros_Events as Events, walkeros_OrderedProperties as OrderedProperties, walkeros_PartialEvent as PartialEvent, walkeros_PromiseOrValue as PromiseOrValue, walkeros_Properties as Properties, walkeros_Property as Property, walkeros_PropertyType as PropertyType, walkeros_SingleOrArray as SingleOrArray, walkeros_Source as Source, walkeros_SourceType as SourceType, walkeros_User as User, walkeros_Version as Version };
 }
 
-interface Fn {
-    name: string;
-    type?: string;
-}
-type OnCall = (context: Fn, args: unknown[]) => void;
-interface Config {
-    dryRun?: boolean;
-    mockReturn?: unknown;
-    onCall?: OnCall;
-}
-type Wrap = <T>(name: string, originalFn: T) => T;
-
-type wrapper_Config = Config;
-type wrapper_Fn = Fn;
-type wrapper_OnCall = OnCall;
-type wrapper_Wrap = Wrap;
-declare namespace wrapper {
-  export type { wrapper_Config as Config, wrapper_Fn as Fn, wrapper_OnCall as OnCall, wrapper_Wrap as Wrap };
-}
-
 type StorageType = 'local' | 'session' | 'cookie';
 declare const Const: {
     readonly Utils: {
@@ -778,7 +788,7 @@ declare function createDestination<Settings = unknown, Mapping = unknown>(baseDe
  * });
  * ```
  */
-declare function createSource<T extends Config$1, E = unknown>(source: Init<T, E>, config: Partial<T>): Init<T, E>;
+declare function createSource<T extends Config, E = unknown>(source: Init<T, E>, config: Partial<T>): Init<T, E>;
 
 /**
  * Creates a complete event with default values.
@@ -1110,13 +1120,4 @@ declare function validateEvent(obj: unknown, customContracts?: Contracts): Event
  */
 declare function validateProperty(obj: AnyObject, key: string, value: unknown, schema: Property$1): Property | never;
 
-/**
- * Creates a wrapper function that can be used to wrap other functions.
- *
- * @param type The type of the wrapper.
- * @param config The configuration for the wrapper.
- * @returns A wrapper function.
- */
-declare function createWrapper(type?: string, { dryRun, mockReturn, onCall }?: Config): Wrap;
-
-export { collector as Collector, Const, data as Data, destination as Destination, elb as Elb, 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, wrapper as Wrapper, anonymizeIP, assign, castToProperty, castValue, clone, createDestination, createEvent, createSource, createWrapper, 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, createSource, 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 };