@walkeros/core 0.0.7

package/dist/index.d.ts

@@ -0,0 +1,1122 @@
+/**
+ * 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 */
+    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>;
+    /** Destination configurations */
+    destinations?: InitDestinations;
+    /** Initial custom properties */
+    custom?: Properties;
+    /** Enable verbose logging */
+    verbose: boolean;
+    /** Error handler */
+    onError?: Error;
+    /** Log handler */
+    onLog?: Log;
+}
+type InitConfig$1 = Partial<Config$4>;
+interface SessionData extends Properties {
+    isStart: boolean;
+    storage: boolean;
+    id?: string;
+    start?: number;
+    marketing?: true;
+    updated?: number;
+    isNew?: boolean;
+    device?: string;
+    count?: number;
+    runs?: number;
+}
+interface Sources {
+    [id: string]: CollectorSource;
+}
+interface Destinations$1 {
+    [id: string]: Instance$1;
+}
+interface CollectorSource {
+    type: string;
+    mapping?: unknown;
+    settings?: Record<string, unknown>;
+    elb?: AnyFunction;
+}
+type CommandType = 'action' | 'config' | 'consent' | 'context' | 'destination' | 'elb' | 'globals' | 'hook' | 'init' | 'link' | 'run' | 'user' | 'walker' | string;
+interface Instance$2 {
+    push: Fn$2;
+    allowed: boolean;
+    config: Config$4;
+    consent: Consent;
+    count: number;
+    custom: Properties;
+    sources: Sources;
+    destinations: Destinations$1;
+    globals: Properties;
+    group: string;
+    hooks: Functions;
+    on: OnConfig;
+    queue: Events;
+    round: number;
+    session: undefined | SessionData;
+    timing: number;
+    user: User;
+    version: string;
+}
+
+type collector_CollectorSource = CollectorSource;
+type collector_CommandType = CommandType;
+type collector_SessionData = SessionData;
+type collector_Sources = Sources;
+declare namespace collector {
+  export type { collector_CollectorSource as CollectorSource, 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 };
+}
+
+interface Contract$1 {
+    version: string;
+    globals: Globals;
+    context: Contexts;
+    entities: Entities$1;
+}
+interface Globals {
+    [name: string]: Global;
+}
+interface Contexts {
+    [name: string]: Context$2;
+}
+interface Entities$1 {
+    [name: string]: Entity$1;
+}
+interface Properties$2 {
+    [name: string]: Property$2;
+}
+interface Global extends Property$2 {
+}
+interface Context$2 extends Property$2 {
+}
+interface Entity$1 {
+    data: Properties$2;
+    actions: Actions;
+}
+interface Actions {
+    [name: string]: Action;
+}
+interface Action {
+    trigger?: Trigger;
+}
+type Trigger = string;
+interface Property$2 {
+    type?: PropertyType$1;
+    required?: boolean;
+    values?: PropertyValues;
+}
+type PropertyType$1 = 'boolean' | 'string' | 'number';
+type PropertyValues = Array<Property>;
+
+type data_Action = Action;
+type data_Actions = Actions;
+type data_Contexts = Contexts;
+type data_Global = Global;
+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 };
+}
+
+interface Instance$1<Settings = unknown, Mapping = unknown> {
+    config: Config$3<Settings, Mapping>;
+    queue?: Events;
+    dlq?: DLQ;
+    type?: string;
+    init?: InitFn<Settings, Mapping>;
+    push: PushFn<Settings, Mapping>;
+    pushBatch?: PushBatchFn<Settings, Mapping>;
+}
+interface Config$3<Settings = unknown, Mapping = unknown> {
+    consent?: Consent;
+    settings?: Settings;
+    data?: Value | Values;
+    dryRun?: boolean;
+    id?: string;
+    init?: boolean;
+    loadScript?: boolean;
+    mapping?: Rules<Rule<Mapping>>;
+    on?: Config$2;
+    policy?: Policy;
+    queue?: boolean;
+    verbose?: boolean;
+    wrapper?: Config;
+    onError?: Error;
+    onLog?: Log;
+}
+type PartialConfig<Settings = unknown, Mapping = unknown> = Config$3<Partial<Settings> | Settings, Partial<Mapping> | Mapping>;
+interface Policy {
+    [key: string]: Value;
+}
+type Init$1 = Partial<Omit<Instance$1, 'push'>> & Pick<Instance$1, 'push'>;
+type InitDestination<Settings = unknown, Mapping = unknown> = Omit<Instance$1<Settings, Mapping>, 'config'> & {
+    config?: Config$3<Settings, Mapping>;
+};
+interface InitDestinations {
+    [key: string]: InitDestination<any, any>;
+}
+interface Destinations {
+    [key: string]: Instance$1;
+}
+interface Context$1<Settings = unknown, Mapping = unknown> {
+    collector: Instance$2;
+    config: Config$3<Settings, Mapping>;
+    data?: Data$1;
+    wrap: Wrap;
+}
+interface PushContext<Settings = unknown, Mapping = unknown> extends Context$1<Settings, Mapping> {
+    mapping?: Rule<Mapping>;
+}
+interface PushBatchContext<Settings = unknown, Mapping = unknown> extends Context$1<Settings, Mapping> {
+    mapping?: Rule<Mapping>;
+}
+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 PushEvent<Mapping = unknown> = {
+    event: Event;
+    mapping?: Rule<Mapping>;
+};
+type PushEvents<Mapping = unknown> = Array<PushEvent<Mapping>>;
+interface Batch<Mapping> {
+    key: string;
+    events: Events;
+    data: Array<Data$1>;
+    mapping?: Rule<Mapping>;
+}
+type Data$1 = Property | undefined | Array<Property | undefined>;
+type Ref = {
+    id: string;
+    destination: Instance$1;
+};
+type Push = {
+    queue?: Events;
+    error?: unknown;
+};
+type DLQ = Array<[Event, unknown]>;
+type Result$1 = {
+    successful: Array<Ref>;
+    queued: Array<Ref>;
+    failed: Array<Ref>;
+};
+
+type destination_Batch<Mapping> = Batch<Mapping>;
+type destination_DLQ = DLQ;
+type destination_Destinations = Destinations;
+type destination_InitDestination<Settings = unknown, Mapping = unknown> = InitDestination<Settings, Mapping>;
+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_PushEvent<Mapping = unknown> = PushEvent<Mapping>;
+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 };
+}
+
+interface EventFn<R = Promise<PushResult>> {
+    (partialEvent: DeepPartialEvent): R;
+    (event: string): R;
+    (event: string, data: Properties): R;
+}
+interface Fn$2<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
+}
+interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
+    (event: 'walker config', config: Partial<Config>): R;
+    (event: 'walker consent', consent: Consent): R;
+    (event: 'walker destination', destination: Init$1 | Instance$1, config?: Config$3): 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 user', user: User): R;
+    (event: 'walker run', runState: {
+        consent?: Consent;
+        user?: User;
+        globals?: Properties;
+        custom?: Properties;
+    }): R;
+}
+type Event$1<R = Promise<PushResult>> = (partialEvent: DeepPartialEvent) => R;
+type PushData<Config = unknown> = DeepPartial<Config> | Consent | User | Properties;
+interface PushResult extends Result$1 {
+    event?: Event;
+    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$2 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_RegisterDestination as RegisterDestination, elb_WalkerCommands as WalkerCommands };
+}
+
+type Error = (error: unknown, state?: unknown) => void;
+type Log = (message: string, verbose?: boolean) => void;
+
+type handler_Error = Error;
+type handler_Log = Log;
+declare namespace handler {
+  export type { handler_Error as Error, handler_Log as Log };
+}
+
+type AnyFunction$1<P extends unknown[] = never[], R = unknown> = (...args: P) => R;
+type Functions = {
+    [key: string]: AnyFunction$1;
+};
+interface Parameter<P extends unknown[], R> {
+    fn: (...args: P) => R;
+    result?: R;
+}
+type HookFn<T extends AnyFunction$1> = (params: Parameter<Parameters<T>, ReturnType<T>>, ...args: Parameters<T>) => ReturnType<T>;
+
+type hooks_Functions = Functions;
+type hooks_HookFn<T extends AnyFunction$1> = HookFn<T>;
+declare namespace hooks {
+  export type { AnyFunction$1 as AnyFunction, hooks_Functions as Functions, hooks_HookFn as HookFn };
+}
+
+interface Rules<T = Rule> {
+    [entity: string]: Record<string, T | Array<T>> | undefined;
+}
+interface Rule<Settings = unknown> {
+    batch?: number;
+    batchFn?: (destination: Instance$1, collector: Instance$2) => void;
+    batched?: Batch<Settings>;
+    condition?: Condition;
+    consent?: Consent;
+    settings?: Settings;
+    data?: Data;
+    ignore?: boolean;
+    name?: string;
+}
+interface Result {
+    eventMapping?: Rule;
+    mappingKey?: string;
+}
+type Data = Value | Values;
+type Value = ValueType | Array<ValueType>;
+type Values = Array<Value>;
+type ValueType = string | ValueConfig;
+interface ValueConfig {
+    condition?: Condition;
+    consent?: Consent;
+    fn?: Fn$1;
+    key?: string;
+    loop?: Loop;
+    map?: Map;
+    set?: Value[];
+    validate?: Validate;
+    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 Loop = [Value, Value];
+type Map = {
+    [key: string]: Value;
+};
+interface Options$1 {
+    consent?: Consent;
+    collector?: Instance$2;
+    props?: unknown;
+}
+type Validate = (value?: unknown) => PromiseOrValue<boolean>;
+
+type mapping_Condition = Condition;
+type mapping_Data = Data;
+type mapping_Loop = Loop;
+type mapping_Map = Map;
+type mapping_Result = Result;
+type mapping_Rule<Settings = unknown> = Rule<Settings>;
+type mapping_Rules<T = Rule> = Rules<T>;
+type mapping_Validate = Validate;
+type mapping_Value = Value;
+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 };
+}
+
+type Config$2 = {
+    consent?: Array<ConsentConfig>;
+    ready?: Array<ReadyConfig>;
+    run?: Array<RunConfig>;
+    session?: Array<SessionConfig>;
+};
+type Types = keyof Config$2;
+type Options = ConsentConfig | ReadyConfig | RunConfig | SessionConfig;
+interface ConsentConfig {
+    [key: string]: ConsentFn;
+}
+type ConsentFn = (collector: Instance$2, consent: Consent) => void;
+type ReadyConfig = ReadyFn;
+type ReadyFn = (collector: Instance$2) => void;
+type RunConfig = RunFn;
+type RunFn = (collector: Instance$2) => void;
+type SessionConfig = SessionFn;
+type SessionFn = (collector: Instance$2, session?: unknown) => void;
+interface OnConfig {
+    consent?: ConsentConfig[];
+    ready?: ReadyConfig[];
+    run?: RunConfig[];
+    session?: SessionConfig[];
+    [key: string]: ConsentConfig[] | ReadyConfig[] | RunConfig[] | SessionConfig[] | undefined;
+}
+
+type on_ConsentConfig = ConsentConfig;
+type on_ConsentFn = ConsentFn;
+type on_OnConfig = OnConfig;
+type on_Options = Options;
+type on_ReadyConfig = ReadyConfig;
+type on_ReadyFn = ReadyFn;
+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$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 };
+}
+
+interface Context {
+    city?: string;
+    country?: string;
+    encoding?: string;
+    hash?: string;
+    ip?: string;
+    language?: string;
+    origin?: string;
+    region?: string;
+    userAgent?: string;
+    [key: string]: string | undefined;
+}
+
+type request_Context = Context;
+declare namespace request {
+  export type { request_Context as Context };
+}
+
+type Contracts = Array<Contract>;
+type Contract = {
+    [entity: string]: {
+        [action: string]: Properties$1;
+    };
+};
+type Properties$1 = {
+    [key: string]: Property$1 | undefined;
+};
+type Property$1 = {
+    allowedKeys?: string[];
+    allowedValues?: unknown[];
+    maxLength?: number;
+    max?: number;
+    min?: number;
+    required?: boolean;
+    schema?: Properties$1;
+    strict?: boolean;
+    type?: string;
+    validate?: (value: unknown, key: string, event: AnyObject) => Property;
+};
+
+type schema_Contract = Contract;
+type schema_Contracts = Contracts;
+declare namespace schema {
+  export type { schema_Contract as Contract, schema_Contracts as Contracts, Properties$1 as Properties, Property$1 as Property };
+}
+
+interface Config$1 {
+    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> {
+    (collector: Instance$2, config: T): CreateSource<T, E> | Promise<CreateSource<T, E>>;
+}
+interface CreateSource<T extends Config$1 = Config$1, E = AnyFunction> {
+    source?: Instance<T>;
+    elb?: E;
+}
+interface Instance<T extends Config$1 = Config$1> {
+    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_InitConfig = InitConfig;
+type source_Instance<T extends Config$1 = Config$1> = 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 };
+}
+
+type AnyObject<T = unknown> = Record<string, T>;
+type Elb = globalThis.WalkerOS.Elb;
+type AnyFunction = (...args: unknown[]) => unknown;
+type SingleOrArray<T> = T | Array<T>;
+declare global {
+    namespace WalkerOS {
+        interface Elb extends Fn$2 {
+        }
+    }
+}
+type Events = Array<Event>;
+type PartialEvent = Partial<Event>;
+type DeepPartialEvent = DeepPartial<Event>;
+interface Event {
+    event: string;
+    data: Properties;
+    context: OrderedProperties;
+    globals: Properties;
+    custom: Properties;
+    user: User;
+    nested: Entities;
+    consent: Consent;
+    id: string;
+    trigger: string;
+    entity: string;
+    action: string;
+    timestamp: number;
+    timing: number;
+    group: string;
+    count: number;
+    version: Version;
+    source: Source;
+}
+interface Consent {
+    [name: string]: boolean;
+}
+interface User extends Properties {
+    id?: string;
+    device?: string;
+    session?: string;
+    hash?: string;
+    address?: string;
+    email?: string;
+    phone?: string;
+    userAgent?: string;
+    browser?: string;
+    browserVersion?: string;
+    deviceType?: string;
+    language?: string;
+    country?: string;
+    region?: string;
+    city?: string;
+    zip?: string;
+    timezone?: string;
+    os?: string;
+    osVersion?: string;
+    screenSize?: string;
+    ip?: string;
+    internal?: boolean;
+}
+interface Version extends Properties {
+    source: string;
+    tagging: number;
+}
+interface Source extends Properties {
+    type: SourceType;
+    id: string;
+    previous_id: string;
+}
+type SourceType = 'web' | 'server' | 'app' | 'other' | string;
+type PropertyType = boolean | string | number | {
+    [key: string]: Property;
+};
+type Property = PropertyType | Array<PropertyType>;
+interface Properties {
+    [key: string]: Property | undefined;
+}
+interface OrderedProperties {
+    [key: string]: [Property, number] | undefined;
+}
+type Entities = Array<Entity>;
+interface Entity {
+    type: string;
+    data: Properties;
+    nested: Entities;
+    context: OrderedProperties;
+}
+type ConsentHandler = Record<string, AnyFunction>;
+type ActionHandler = AnyFunction;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type PromiseOrValue<T> = T | Promise<T>;
+
+type walkeros_ActionHandler = ActionHandler;
+type walkeros_AnyFunction = AnyFunction;
+type walkeros_AnyObject<T = unknown> = AnyObject<T>;
+type walkeros_Consent = Consent;
+type walkeros_ConsentHandler = ConsentHandler;
+type walkeros_DeepPartial<T> = DeepPartial<T>;
+type walkeros_DeepPartialEvent = DeepPartialEvent;
+type walkeros_Elb = Elb;
+type walkeros_Entities = Entities;
+type walkeros_Entity = Entity;
+type walkeros_Event = Event;
+type walkeros_Events = Events;
+type walkeros_OrderedProperties = OrderedProperties;
+type walkeros_PartialEvent = PartialEvent;
+type walkeros_PromiseOrValue<T> = PromiseOrValue<T>;
+type walkeros_Properties = Properties;
+type walkeros_Property = Property;
+type walkeros_PropertyType = PropertyType;
+type walkeros_SingleOrArray<T> = SingleOrArray<T>;
+type walkeros_Source = Source;
+type walkeros_SourceType = SourceType;
+type walkeros_User = User;
+type walkeros_Version = Version;
+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: {
+        readonly Storage: {
+            readonly Local: "local";
+            readonly Session: "session";
+            readonly Cookie: "cookie";
+        };
+    };
+};
+
+/**
+ * Anonymizes an IPv4 address by setting the last octet to 0.
+ *
+ * @param ip The IP address to anonymize.
+ * @returns The anonymized IP address or an empty string if the IP is invalid.
+ */
+declare function anonymizeIP(ip: string): string;
+
+/**
+ * @interface Assign
+ * @description Options for the assign function.
+ * @property merge - Merge array properties instead of overriding them.
+ * @property shallow - Create a shallow copy instead of updating the target object.
+ * @property extend - Extend the target with new properties instead of only updating existing ones.
+ */
+interface Assign {
+    merge?: boolean;
+    shallow?: boolean;
+    extend?: boolean;
+}
+/**
+ * Merges objects with advanced options.
+ *
+ * @template T, U
+ * @param target - The target object to merge into.
+ * @param obj - The source object to merge from.
+ * @param options - Options for merging.
+ * @returns The merged object.
+ */
+declare function assign<T extends object, U extends object>(target: T, obj?: U, options?: Assign): T & U;
+
+/**
+ * Gets a value from an object by a dot-notation string.
+ * Supports wildcards for arrays.
+ *
+ * @example
+ * getByPath({ data: { id: 1 } }, "data.id") // Returns 1
+ *
+ * @param event - The object to get the value from.
+ * @param key - The dot-notation string.
+ * @param defaultValue - The default value to return if the key is not found.
+ * @returns The value from the object or the default value.
+ */
+declare function getByPath(event: unknown, key?: string, defaultValue?: unknown): unknown;
+/**
+ * Sets a value in an object by a dot-notation string.
+ *
+ * @param event - 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;
+
+/**
+ * Casts a value to a specific type.
+ *
+ * @param value The value to cast.
+ * @returns The casted value.
+ */
+declare function castValue(value: unknown): PropertyType;
+
+/**
+ * Creates a deep clone of a value.
+ * Supports primitive values, objects, arrays, dates, and regular expressions.
+ * Handles circular references.
+ *
+ * @template T
+ * @param org - The value to clone.
+ * @param visited - A map of visited objects to handle circular references.
+ * @returns The cloned value.
+ */
+declare function clone<T>(org: T, visited?: WeakMap<object, unknown>): T;
+
+/**
+ * Checks if the required consent is granted.
+ *
+ * @param required - The required consent states.
+ * @param state - The current consent states.
+ * @param individual - Individual consent states to prioritize.
+ * @returns The granted consent states or false if not granted.
+ */
+declare function getGrantedConsent(required: Consent | undefined, state?: Consent, individual?: Consent): false | Consent;
+
+/**
+ * Creates a new destination instance by merging a base destination with additional configuration.
+ *
+ * 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:
+ * 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>;
+
+/**
+ * Creates a new source function by merging a base source with additional configuration.
+ *
+ * This utility enables elegant source configuration while avoiding config side-effects
+ * that could occur when reusing source functions across multiple collector instances.
+ *
+ * @template T - The source config type extending Source.Config
+ * @template E - The source elb function type
+ * @param source - The base source function to extend
+ * @param config - Additional configuration to merge with the source's config
+ * @returns A new source function with merged configuration
+ *
+ * @example
+ * ```typescript
+ * import { createSource } from '@walkeros/core';
+ * import { sourceBrowser } from '@walkeros/web-source-browser';
+ *
+ * const configuredSource = createSource(sourceBrowser, {
+ *   settings: {
+ *     scope: document.body,
+ *     session: true
+ *   }
+ * });
+ *
+ * const { elb } = await createCollector({
+ *   sources: {
+ *     browser: configuredSource
+ *   }
+ * });
+ * ```
+ */
+declare function createSource<T extends Config$1, E = unknown>(source: Init<T, E>, config: Partial<T>): Init<T, E>;
+
+/**
+ * Creates a complete event with default values.
+ * Used for testing and debugging.
+ *
+ * @param props - Properties to override the default values.
+ * @returns A complete event.
+ */
+declare function createEvent(props?: DeepPartialEvent): Event;
+/**
+ * Creates a complete event with default values based on the event name.
+ * Used for testing and debugging.
+ *
+ * @param name - The name of the event to create.
+ * @param props - Properties to override the default values.
+ * @returns A complete event.
+ */
+declare function getEvent(name?: string, props?: DeepPartialEvent): Event;
+
+/**
+ * Generates a random string of a given length.
+ *
+ * @param length - The length of the random string.
+ * @returns The random string.
+ */
+declare function getId(length?: number): string;
+
+interface MarketingParameters {
+    [key: string]: string;
+}
+/**
+ * Extracts marketing parameters from a URL.
+ *
+ * @param url - The URL to extract the parameters from.
+ * @param custom - Custom marketing parameters to extract.
+ * @returns The extracted marketing parameters.
+ */
+declare function getMarketingParameters(url: URL, custom?: MarketingParameters): Properties;
+
+/**
+ * Creates a debounced function that delays invoking `fn` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `fn` invocations and a `flush` method to immediately invoke them.
+ *
+ * @template P, R
+ * @param fn The function to debounce.
+ * @param wait The number of milliseconds to delay.
+ * @param immediate Trigger the function on the leading edge, instead of the trailing.
+ * @returns The new debounced function.
+ */
+declare function debounce<P extends unknown[], R>(fn: (...args: P) => R, wait?: number, immediate?: boolean): (...args: P) => Promise<R>;
+declare function throttle<P extends unknown[], R>(fn: (...args: P) => R | undefined, delay?: number): (...args: P) => R | undefined;
+
+/**
+ * Checks if a value is an arguments object.
+ *
+ * @param value The value to check.
+ * @returns True if the value is an arguments object, false otherwise.
+ */
+declare function isArguments(value: unknown): value is IArguments;
+/**
+ * Checks if a value is an array.
+ *
+ * @param value The value to check.
+ * @returns True if the value is an array, false otherwise.
+ */
+declare function isArray<T>(value: unknown): value is T[];
+/**
+ * Checks if a value is a boolean.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a boolean, false otherwise.
+ */
+declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if an entity is a walker command.
+ *
+ * @param entity The entity to check.
+ * @returns True if the entity is a walker command, false otherwise.
+ */
+declare function isCommand(entity: string): entity is "walker";
+/**
+ * Checks if a value is defined.
+ *
+ * @param value The value to check.
+ * @returns True if the value is defined, false otherwise.
+ */
+declare function isDefined<T>(val: T | undefined): val is T;
+/**
+ * Checks if a value is an element or the document.
+ *
+ * @param elem The value to check.
+ * @returns True if the value is an element or the document, false otherwise.
+ */
+declare function isElementOrDocument(elem: unknown): elem is Element;
+/**
+ * Checks if a value is a function.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a function, false otherwise.
+ */
+declare function isFunction(value: unknown): value is Function;
+/**
+ * Checks if a value is a number.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a number, false otherwise.
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is an object.
+ *
+ * @param value The value to check.
+ * @returns True if the value is an object, false otherwise.
+ */
+declare function isObject(value: unknown): value is AnyObject;
+/**
+ * Checks if two variables have the same type.
+ *
+ * @param variable The first variable.
+ * @param type The second variable.
+ * @returns True if the variables have the same type, false otherwise.
+ */
+declare function isSameType<T>(variable: unknown, type: T): variable is typeof type;
+/**
+ * Checks if a value is a string.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a string, false otherwise.
+ */
+declare function isString(value: unknown): value is string;
+
+/**
+ * Gets the mapping for an event.
+ *
+ * @param event The event to get the mapping for.
+ * @param mapping The mapping rules.
+ * @returns The mapping result.
+ */
+declare function getMappingEvent(event: PartialEvent, mapping?: Rules): Promise<Result>;
+/**
+ * Gets a value from a mapping.
+ *
+ * @param value The value to get the mapping from.
+ * @param data The mapping data.
+ * @param options The mapping options.
+ * @returns The mapped value.
+ */
+declare function getMappingValue(value: DeepPartialEvent | unknown | undefined, data?: Data, options?: Options$1): Promise<Property | undefined>;
+
+/**
+ * Logs a message to the console if verbose logging is enabled.
+ *
+ * @param message The message to log.
+ * @param verbose Whether to log the message.
+ */
+declare function onLog(message: unknown, verbose?: boolean): void;
+
+/**
+ * Checks if a value is a valid property type.
+ *
+ * @param value The value to check.
+ * @returns True if the value is a valid property type, false otherwise.
+ */
+declare function isPropertyType(value: unknown): value is PropertyType;
+/**
+ * Filters a value to only include valid property types.
+ *
+ * @param value The value to filter.
+ * @returns The filtered value or undefined.
+ */
+declare function filterValues(value: unknown): Property | undefined;
+/**
+ * Casts a value to a valid property type.
+ *
+ * @param value The value to cast.
+ * @returns The casted value or undefined.
+ */
+declare function castToProperty(value: unknown): Property | undefined;
+
+/**
+ * Converts a request string to a data object.
+ *
+ * @param parameter The request string to convert.
+ * @returns The data object or undefined.
+ */
+declare function requestToData(parameter: unknown): AnyObject | undefined;
+/**
+ * Converts a data object to a request string.
+ *
+ * @param data The data object to convert.
+ * @returns The request string.
+ */
+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.
+ *
+ * @param data The data to transform.
+ * @returns The transformed data.
+ */
+declare function transformData(data?: SendDataValue): string | undefined;
+/**
+ * Gets the headers for a request.
+ *
+ * @param headers The headers to merge with the default headers.
+ * @returns The merged headers.
+ */
+declare function getHeaders(headers?: SendHeaders): SendHeaders;
+
+/**
+ * Throws an error.
+ *
+ * @param error The error to throw.
+ */
+declare function throwError(error: unknown): never;
+
+/**
+ * Trims quotes and whitespaces from a string.
+ *
+ * @param str The string to trim.
+ * @returns The trimmed string.
+ */
+declare function trim(str: string): string;
+
+/**
+ * A utility function that wraps a function in a try-catch block.
+ *
+ * @template P, R, S
+ * @param fn The function to wrap.
+ * @param onError A function to call when an error is caught.
+ * @param onFinally A function to call in the finally block.
+ * @returns The wrapped function.
+ */
+declare function tryCatch<P extends unknown[], R, S>(fn: (...args: P) => R | undefined, onError: (err: unknown) => S, onFinally?: () => void): (...args: P) => R | S;
+declare function tryCatch<P extends unknown[], R>(fn: (...args: P) => R | undefined, onError?: undefined, onFinally?: () => void): (...args: P) => R | undefined;
+/**
+ * A utility function that wraps an async function in a try-catch block.
+ *
+ * @template P, R, S
+ * @param fn The async function to wrap.
+ * @param onError A function to call when an error is caught.
+ * @param onFinally A function to call in the finally block.
+ * @returns The wrapped async function.
+ */
+declare function tryCatchAsync<P extends unknown[], R, S>(fn: (...args: P) => R, onError: (err: unknown) => S, onFinally?: () => void | Promise<void>): (...args: P) => Promise<R | S>;
+declare function tryCatchAsync<P extends unknown[], R>(fn: (...args: P) => R, onError?: undefined, onFinally?: () => void | Promise<void>): (...args: P) => Promise<R | undefined>;
+
+/**
+ * A utility function that wraps a function with hooks.
+ *
+ * @template P, R
+ * @param fn The function to wrap.
+ * @param name The name of the function.
+ * @param hooks The hooks to use.
+ * @returns The wrapped function.
+ */
+declare function useHooks<P extends unknown[], R>(fn: (...args: P) => R, name: string, hooks: Functions): (...args: P) => R;
+
+/**
+ * Parses a user agent string to extract browser, OS, and device information.
+ *
+ * @param userAgent The user agent string to parse.
+ * @returns An object containing the parsed user agent information.
+ */
+declare function parseUserAgent(userAgent?: string): User;
+/**
+ * Gets the browser name from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The browser name or undefined.
+ */
+declare function getBrowser(userAgent: string): string | undefined;
+/**
+ * Gets the browser version from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The browser version or undefined.
+ */
+declare function getBrowserVersion(userAgent: string): string | undefined;
+/**
+ * Gets the OS name from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The OS name or undefined.
+ */
+declare function getOS(userAgent: string): string | undefined;
+/**
+ * Gets the OS version from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The OS version or undefined.
+ */
+declare function getOSVersion(userAgent: string): string | undefined;
+/**
+ * Gets the device type from a user agent string.
+ *
+ * @param userAgent The user agent string.
+ * @returns The device type or undefined.
+ */
+declare function getDeviceType(userAgent: string): string | undefined;
+
+/**
+ * Validates an event against a set of contracts.
+ *
+ * @param obj The event to validate.
+ * @param customContracts The custom contracts to use.
+ * @returns The validated event.
+ */
+declare function validateEvent(obj: unknown, customContracts?: Contracts): Event | never;
+/**
+ * Validates a property against a schema.
+ *
+ * @param obj The object to validate.
+ * @param key The key of the property to validate.
+ * @param value The value of the property to validate.
+ * @param schema The schema to validate against.
+ * @returns The validated property.
+ */
+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 };