/**
 * idl.ts — verify-proof IDL v1 verb definitions + arg/return shapes.
 *
 * Wire contract per ID-01: workflow prose, the resolver, verification.json,
 * and third-party drivers all refer to IDL verbs (`click`, `screenshot`,
 * `assert_visible`, ...) and NEVER to concrete MCP tool names. The mapping
 * from a verb to a transport (mcp_server_id / local_command / http_endpoint /
 * builtin) lives in the driver's manifest + driver.mjs, not here.
 *
 * Five verb families:
 *   - lifecycle: launch / teardown
 *   - interaction: click / type / key / navigate / select / upload_file /
 *     drag_drop / swipe / switch_context / execute_js / wait_for_event /
 *     wait_for_idle
 *   - evidence: screenshot / record_video / capture_logs / dump_state /
 *     dom_dump
 *   - assertion: assert_visible / assert_text / assert_output /
 *     assert_network
 *   - async: trigger / await_signal
 */
/** How a driver locates a UI element. `screen_coord` is last-resort. */
export type TargetKind = 'aria_role' | 'test_id' | 'css' | 'xpath' | 'screen_coord';
/** A locator the driver translates into a transport-specific selector. */
export interface Target {
    readonly kind: TargetKind;
    readonly value: string;
}
export interface LaunchArgs {
    readonly entrypoint?: string;
    readonly env?: Readonly<Record<string, string>>;
    readonly cwd?: string;
}
export interface Handle {
    readonly handle_id: string;
}
export interface TeardownArgs {
    readonly handle: Handle;
}
export interface ClickArgs {
    readonly target: Target;
    readonly button?: 'left' | 'right' | 'middle';
}
export interface TypeArgs {
    readonly target: Target;
    readonly text: string;
    readonly clear_first?: boolean;
}
export interface KeyArgs {
    readonly target?: Target;
    readonly key: string;
}
export interface NavigateArgs {
    readonly url: string;
}
export interface SelectArgs {
    readonly target: Target;
    readonly value: string;
}
export interface UploadFileArgs {
    readonly target: Target;
    readonly file_path: string;
}
export interface DragDropArgs {
    readonly source: Target;
    readonly destination: Target;
}
export interface SwipeArgs {
    readonly target: Target;
    readonly direction: 'up' | 'down' | 'left' | 'right';
}
export interface SwitchContextArgs {
    readonly handle: Handle;
}
export interface ExecuteJsArgs {
    readonly script: string;
    /** Optional args passed positionally into the script. */
    readonly args?: readonly unknown[];
}
export interface WaitForEventArgs {
    readonly event: string;
    readonly timeout_ms?: number;
}
export interface WaitForIdleArgs {
    readonly timeout_ms?: number;
}
export interface ScreenshotArgs {
    readonly target?: Target;
    readonly output_path: string;
}
export interface RecordVideoArgs {
    readonly duration_seconds: number;
    readonly fps?: number;
    readonly output_path: string;
}
export interface CaptureLogsArgs {
    readonly source: 'console' | 'stdout' | 'stderr' | 'all';
    readonly output_path?: string;
}
export interface DumpStateArgs {
    readonly output_path: string;
}
export interface DomDumpArgs {
    readonly output_path: string;
}
export interface AssertVisibleArgs {
    readonly target: Target;
}
export interface AssertTextArgs {
    readonly target: Target;
    readonly expected: string;
    readonly match?: 'exact' | 'contains' | 'regex';
}
export interface AssertOutputArgs {
    readonly source: 'stdout' | 'stderr' | 'console';
    readonly expected: string;
    readonly match?: 'exact' | 'contains' | 'regex';
}
export interface AssertNetworkArgs {
    readonly url_pattern: string;
    readonly method?: string;
    readonly expected_status?: number;
}
export interface TriggerArgs {
    readonly event: string;
    readonly payload?: unknown;
}
export interface AwaitSignalArgs {
    readonly signal: string;
    readonly timeout_ms?: number;
}
export interface VerbResult {
    readonly status: 'success' | 'fail' | 'skip';
    readonly evidence_paths: readonly string[];
    readonly duration_ms: number;
    readonly retry_count: number;
    readonly error?: string;
}
/** Lifecycle verbs. */
export declare const LIFECYCLE_VERBS: readonly ["launch", "teardown"];
/** Interaction verbs. */
export declare const INTERACTION_VERBS: readonly ["click", "type", "key", "navigate", "select", "upload_file", "drag_drop", "swipe", "switch_context", "execute_js", "wait_for_event", "wait_for_idle"];
/** Evidence verbs. */
export declare const EVIDENCE_VERBS: readonly ["screenshot", "record_video", "capture_logs", "dump_state", "dom_dump"];
/** Assertion verbs. */
export declare const ASSERTION_VERBS: readonly ["assert_visible", "assert_text", "assert_output", "assert_network"];
/** Async verbs. */
export declare const ASYNC_VERBS: readonly ["trigger", "await_signal"];
/** Every IDL v1 verb name, flat array — the canonical list. */
export declare const IDL_VERB_NAMES: readonly string[];
/** The union type of every verb name. */
export type IdlVerbName = (typeof LIFECYCLE_VERBS)[number] | (typeof INTERACTION_VERBS)[number] | (typeof EVIDENCE_VERBS)[number] | (typeof ASSERTION_VERBS)[number] | (typeof ASYNC_VERBS)[number];
/**
 * Per-verb arg metadata. `required` lists keys that MUST be present on the
 * args object; `optional` lists keys that MAY be present. Bundled drivers
 * and third-party drivers both consume this through validateVerbArgs() so
 * the SDK is the single source of truth (ID-04).
 *
 * Frozen so consumers don't mutate the registry by accident.
 */
export declare const IDL_VERB_ARGS: Readonly<Record<string, {
    readonly required: readonly string[];
    readonly optional: readonly string[];
}>>;
/**
 * VerbResult return-shape predicate. Drivers MUST return an object with
 * `status` ∈ {success,fail,skip}, `evidence_paths` (array), `duration_ms`
 * (number), and `retry_count` (number). The conformance kit + framework
 * resolver call this to validate runtime return shapes.
 */
export declare function isVerbResult(value: unknown): boolean;
/**
 * Validate a verb's args object against the IDL_VERB_ARGS registry. Returns
 * `{valid: true}` when every required key is present; otherwise returns
 * `{valid: false, missing: [...keys]}` where `missing` includes the keys
 * that were absent (or `['unknown verb: <name>']` for unknown verbs).
 */
export declare function validateVerbArgs(verb: string, args: unknown): {
    valid: true;
} | {
    valid: false;
    missing: string[];
};
/**
 * Driver-shaped interface — a driver exports a subset of these functions
 * keyed by IDL verb name. The resolver introspects this surface to validate
 * `manifest.capabilities[]` matches the runtime exports.
 *
 * Every method is async + returns VerbResult. Drivers MAY omit verbs they
 * don't implement — the manifest's `capabilities[]` array is the source of
 * truth for what each driver claims.
 */
export interface DriverModule {
    readonly launch?: (args: LaunchArgs) => Promise<VerbResult & {
        handle?: Handle;
    }>;
    readonly teardown?: (args: TeardownArgs) => Promise<VerbResult>;
    readonly click?: (args: ClickArgs) => Promise<VerbResult>;
    readonly type?: (args: TypeArgs) => Promise<VerbResult>;
    readonly key?: (args: KeyArgs) => Promise<VerbResult>;
    readonly navigate?: (args: NavigateArgs) => Promise<VerbResult>;
    readonly select?: (args: SelectArgs) => Promise<VerbResult>;
    readonly upload_file?: (args: UploadFileArgs) => Promise<VerbResult>;
    readonly drag_drop?: (args: DragDropArgs) => Promise<VerbResult>;
    readonly swipe?: (args: SwipeArgs) => Promise<VerbResult>;
    readonly switch_context?: (args: SwitchContextArgs) => Promise<VerbResult>;
    readonly execute_js?: (args: ExecuteJsArgs) => Promise<VerbResult>;
    readonly wait_for_event?: (args: WaitForEventArgs) => Promise<VerbResult>;
    readonly wait_for_idle?: (args: WaitForIdleArgs) => Promise<VerbResult>;
    readonly screenshot?: (args: ScreenshotArgs) => Promise<VerbResult>;
    readonly record_video?: (args: RecordVideoArgs) => Promise<VerbResult>;
    readonly capture_logs?: (args: CaptureLogsArgs) => Promise<VerbResult>;
    readonly dump_state?: (args: DumpStateArgs) => Promise<VerbResult>;
    readonly dom_dump?: (args: DomDumpArgs) => Promise<VerbResult>;
    readonly assert_visible?: (args: AssertVisibleArgs) => Promise<VerbResult>;
    readonly assert_text?: (args: AssertTextArgs) => Promise<VerbResult>;
    readonly assert_output?: (args: AssertOutputArgs) => Promise<VerbResult>;
    readonly assert_network?: (args: AssertNetworkArgs) => Promise<VerbResult>;
    readonly trigger?: (args: TriggerArgs) => Promise<VerbResult>;
    readonly await_signal?: (args: AwaitSignalArgs) => Promise<VerbResult>;
}
//# sourceMappingURL=idl.d.ts.map