import * as _walkeros_core_dev from '@walkeros/core/dev';
import { z } from '@walkeros/core/dev';
import { Source, Elb, Flow, Trigger } from '@walkeros/core';

/**
 * Data attribute prefix
 * Used for DOM event tracking
 */
declare const DataAttributePrefix: z.ZodString;
/**
 * JavaScript variable name
 * Used for global function names
 */
declare const JavaScriptVarName: z.ZodString;
/**
 * DOM scope selector
 * Note: Runtime type is Element | Document (non-serializable)
 */
declare const ScopeSelector: z.ZodOptional<z.ZodString>;

/**
 * Browser source settings schema
 */
declare const SettingsSchema: z.ZodObject<{
    prefix: z.ZodDefault<z.ZodString>;
    scope: z.ZodOptional<z.ZodString>;
    pageview: z.ZodDefault<z.ZodBoolean>;
    elb: z.ZodDefault<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    elbLayer: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodAny]>>;
}, z.core.$strip>;
type Settings = z.infer<typeof SettingsSchema>;

/**
 * Tagger configuration schema
 * Used for automatic data attribute generation
 */
declare const TaggerSchema: z.ZodObject<{
    prefix: z.ZodDefault<z.ZodString>;
}, z.core.$strip>;
type TaggerConfig = z.infer<typeof TaggerSchema>;

declare const settings: _walkeros_core_dev.JSONSchema;
declare const tagger: _walkeros_core_dev.JSONSchema;

declare const index$1_DataAttributePrefix: typeof DataAttributePrefix;
declare const index$1_JavaScriptVarName: typeof JavaScriptVarName;
declare const index$1_ScopeSelector: typeof ScopeSelector;
type index$1_Settings = Settings;
declare const index$1_SettingsSchema: typeof SettingsSchema;
type index$1_TaggerConfig = TaggerConfig;
declare const index$1_TaggerSchema: typeof TaggerSchema;
declare const index$1_settings: typeof settings;
declare const index$1_tagger: typeof tagger;
declare namespace index$1 {
  export { index$1_DataAttributePrefix as DataAttributePrefix, index$1_JavaScriptVarName as JavaScriptVarName, index$1_ScopeSelector as ScopeSelector, type index$1_Settings as Settings, index$1_SettingsSchema as SettingsSchema, type index$1_TaggerConfig as TaggerConfig, index$1_TaggerSchema as TaggerSchema, index$1_settings as settings, index$1_tagger as tagger };
}

declare module '@walkeros/core' {
    interface SourceMap {
        browser: {
            type: 'browser';
            platform: 'web';
            url?: string;
            referrer?: string;
        };
    }
}
interface Env extends Source.BaseEnv {
    elb: Elb.Fn;
    window?: Window & typeof globalThis;
    document?: Document;
}

/**
 * Standard mock environment for testing browser source
 *
 * Use this for testing event capture, DOM interactions, and pageview tracking
 * without requiring a real browser environment.
 */
declare const push: Env;

declare const env_push: typeof push;
declare namespace env {
  export { env_push as push };
}

declare const pageView: Flow.StepExample;
declare const clickEvent: Flow.StepExample;
declare const submitEvent: Flow.StepExample;
declare const impressionEvent: Flow.StepExample;
declare const nestedEntities: Flow.StepExample;
declare const dataAttributeTypes: Flow.StepExample;
declare const contextAndGlobals: Flow.StepExample;

declare const step_clickEvent: typeof clickEvent;
declare const step_contextAndGlobals: typeof contextAndGlobals;
declare const step_dataAttributeTypes: typeof dataAttributeTypes;
declare const step_impressionEvent: typeof impressionEvent;
declare const step_nestedEntities: typeof nestedEntities;
declare const step_pageView: typeof pageView;
declare const step_submitEvent: typeof submitEvent;
declare namespace step {
  export { step_clickEvent as clickEvent, step_contextAndGlobals as contextAndGlobals, step_dataAttributeTypes as dataAttributeTypes, step_impressionEvent as impressionEvent, step_nestedEntities as nestedEntities, step_pageView as pageView, step_submitEvent as submitEvent };
}

/**
 * Browser source createTrigger.
 *
 * Injects HTML into the DOM, lazily starts the flow, then calls
 * handleTrigger directly — the same convergence point as production.
 * For load triggers, the source's DOM scan during startFlow handles
 * event capture automatically.
 *
 * @example
 * const { trigger } = await createTrigger(config);
 * await trigger('click', 'button')('<button data-elb="cta" data-elbaction="click:cta click">Click</button>');
 *
 * @example
 * // Impression trigger — handleTrigger reads data-elbaction directly
 * await trigger('impression', '[data-elb="promo"]')('<div data-elb="promo" data-elbaction="visible:promo seen">Ad</div>');
 */
declare const createTrigger: Trigger.CreateFn<string, void>;
/**
 * Browser source trigger (legacy).
 * Converts step example `in` data into DOM elements and dispatches events.
 */
declare const trigger: (input: unknown, env: Record<string, unknown>) => void | (() => void);

declare const index_createTrigger: typeof createTrigger;
declare const index_env: typeof env;
declare const index_step: typeof step;
declare const index_trigger: typeof trigger;
declare namespace index {
  export { index_createTrigger as createTrigger, index_env as env, index_step as step, index_trigger as trigger };
}

export { index as examples, index$1 as schemas };