import { Source, WalkerOS, Elb } from '@walkeros/core';
import { z } from '@walkeros/core/dev';

/**
 * DataLayer source settings schema
 */
declare const SettingsSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodDefault<z.ZodString>>;
    prefix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
    filter: z.ZodOptional<z.ZodAny>;
}, z.core.$strip>;

/**
 * dataLayer source rule.settings — describes how to translate an incoming
 * dataLayer push (gtag command, ecommerce event, etc.) into walker command
 * arguments. `command` is a walkerOS Mapping.Value evaluated against the raw
 * dataLayer arguments at capture time.
 */
declare const MappingSchema: z.ZodObject<{
    command: z.ZodOptional<z.ZodUnknown>;
}, z.core.$strip>;
type Mapping = z.infer<typeof MappingSchema>;

declare module '@walkeros/core' {
    interface SourceMap {
        dataLayer: {
            type: 'dataLayer';
            platform?: 'web';
        };
    }
}
declare global {
    interface Window {
        dataLayer?: DataLayer;
        [key: string]: DataLayer | unknown;
    }
}
type DataLayer = Array<unknown>;
type BaseSettings = z.infer<typeof SettingsSchema>;
interface Settings extends Omit<BaseSettings, 'filter'> {
    name?: string;
    prefix?: string;
    filter?: (event: unknown) => WalkerOS.PromiseOrValue<boolean>;
}
type InitSettings = Partial<Settings>;

type Push = Elb.Fn;
interface Env extends Source.BaseEnv {
    window?: Window & typeof globalThis;
}
type Types = Source.Types<Settings, Mapping, Push, Env, InitSettings>;
type Config = Source.Config<Types>;
type DataLayerEvent = {
    event: string;
    [key: string]: unknown;
};
type MappedEvent = {
    event?: WalkerOS.DeepPartialEvent & {
        id: string;
    };
    command?: {
        name: string;
        data: unknown;
    };
};

type index_Config = Config;
type index_DataLayer = DataLayer;
type index_DataLayerEvent = DataLayerEvent;
type index_Env = Env;
type index_InitSettings = InitSettings;
type index_MappedEvent = MappedEvent;
type index_Mapping = Mapping;
type index_Push = Push;
type index_Settings = Settings;
type index_Types = Types;
declare namespace index {
  export type { index_Config as Config, index_DataLayer as DataLayer, index_DataLayerEvent as DataLayerEvent, index_Env as Env, index_InitSettings as InitSettings, index_MappedEvent as MappedEvent, index_Mapping as Mapping, index_Push as Push, index_Settings as Settings, index_Types as Types };
}

/**
 * DataLayer source implementation using environment injection.
 *
 * This source intercepts dataLayer.push calls and transforms them to WalkerOS events.
 * It works by replacing the dataLayer.push method with a custom handler.
 */
declare const sourceDataLayer: Source.Init<Types>;

export { index as SourceDataLayer, sourceDataLayer as default, sourceDataLayer };