import * as _walkeros_core_dev from '@walkeros/core/dev';
import { z } from '@walkeros/core/dev';
import { Flow, Hint, WalkerOS, Ingest } from '@walkeros/core';

declare const SettingsSchema: z.ZodObject<{
    contract: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    format: z.ZodOptional<z.ZodBoolean>;
    mode: z.ZodOptional<z.ZodEnum<{
        strict: "strict";
        pass: "pass";
    }>>;
    output: z.ZodOptional<z.ZodObject<{
        isValid: z.ZodOptional<z.ZodString>;
        errors: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Settings = z.infer<typeof SettingsSchema>;

declare const settings: _walkeros_core_dev.JSONSchema;

type index$1_Settings = Settings;
declare const index$1_SettingsSchema: typeof SettingsSchema;
declare const index$1_settings: typeof settings;
declare namespace index$1 {
  export { type index$1_Settings as Settings, index$1_SettingsSchema as SettingsSchema, index$1_settings as settings };
}

/**
 * strict + valid: passes the contract, gets annotated source.valid:true and
 * continues down the chain.
 */
declare const strictValidPageView: Flow.StepExample;
/**
 * strict + invalid: the same contract, but data.title is missing. In strict
 * mode the transformer stops the chain (drops). Errors are still written to the
 * ingest for observers; the drop itself is encoded as `['return', false]`.
 */
declare const strictInvalidPageView: Flow.StepExample;
/**
 * pass + invalid: same failure, but mode:'pass' annotates source.valid:false and
 * continues. Downstream destinations route on event.source.valid. The error list
 * is written to the ingest (default path "validation"), not asserted here.
 */
declare const passAnnotateInvalid: Flow.StepExample;
/**
 * gtm filter via a contract pattern: the contract rejects names matching
 * ^gtm\\. There is no `ignore` field; filtering is a contract that fails. In
 * strict mode a "gtm.js" event is dropped.
 */
declare const gtmFilterDropped: Flow.StepExample;
/** Same gtm-filter contract, but a real "page view" passes the pattern. */
declare const gtmFilterPasses: Flow.StepExample;

declare const step_gtmFilterDropped: typeof gtmFilterDropped;
declare const step_gtmFilterPasses: typeof gtmFilterPasses;
declare const step_passAnnotateInvalid: typeof passAnnotateInvalid;
declare const step_strictInvalidPageView: typeof strictInvalidPageView;
declare const step_strictValidPageView: typeof strictValidPageView;
declare namespace step {
  export { step_gtmFilterDropped as gtmFilterDropped, step_gtmFilterPasses as gtmFilterPasses, step_passAnnotateInvalid as passAnnotateInvalid, step_strictInvalidPageView as strictInvalidPageView, step_strictValidPageView as strictValidPageView };
}

declare const index_step: typeof step;
declare namespace index {
  export { index_step as step };
}

declare const hints: Hint.Hints;

/**
 * A single source of validation constraints.
 *
 * Either a resolved `$contract.*` rule (a `Flow.ContractRule` with `.events`
 * entity-action schemas and/or a full-event `.schema`), or an inline whole-event
 * JSON Schema applied to the entire event.
 */
type ContractSource = Flow.ContractRule | Record<string, unknown>;
/** A single validation issue. */
interface ValidationIssue {
    path: string;
    message: string;
    level?: 'error' | 'warn';
}

/**
 * The validation verdict authority. Runs the event through every applicable
 * JSON Schema (AND semantics) and aggregates all @cfworker errors.
 *
 * No matching constraint (empty schema set) means no opinion: isValid is true.
 */
declare function validateEventAgainstContract(event: WalkerOS.DeepPartialEvent, _ingest: Ingest | undefined, opts: {
    contracts?: ContractSource[];
    format?: boolean;
}): {
    isValid: boolean;
    errors: ValidationIssue[];
};

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