/**
 * PreToolUse hook event.
 *
 * Fires before Claude Code executes a tool call. A handler can return
 * `allow`, `deny`, `ask`, or `defer` to control whether the tool is run.
 * Supports a regex matcher on `tool_name`. See
 * https://code.claude.com/docs/en/hooks#pretooluse.
 *
 * @since 0.1.0
 */
import * as Effect from 'effect/Effect';
import * as Schema from 'effect/Schema';
import { HookToolDecodeError } from '../../Errors.js';
import type { HookContext } from '../Context.js';
import type { HookDefinition } from '../Runner.js';
import * as Tool from '../Tool.js';
declare const Input_base: Schema.Class<Input, Schema.Struct<{
    readonly hook_event_name: Schema.Literal<"PreToolUse">;
    readonly tool_name: Schema.String;
    readonly tool_input: Schema.$Record<Schema.String, Schema.Unknown>;
    readonly tool_use_id: Schema.optional<Schema.String>;
    readonly session_id: Schema.String;
    readonly transcript_path: Schema.String;
    readonly cwd: Schema.String;
    readonly permission_mode: Schema.optionalKey<Schema.String>;
    readonly effort: Schema.optionalKey<typeof import("../Envelope.js").HookEffort>;
    readonly agent_id: Schema.optionalKey<Schema.String>;
    readonly agent_type: Schema.optionalKey<Schema.String>;
}>, {}>;
/**
 * Decoded PreToolUse hook input received on stdin.
 *
 * @category Schemas
 * @since 0.1.0
 */
export declare class Input extends Input_base {
}
/**
 * Valid `permissionDecision` values. `defer` suspends a headless tool call
 * for later resumption; omit output entirely for a neutral no-op.
 *
 * @category Schemas
 * @since 0.1.0
 */
export declare const PermissionDecision: Schema.Literals<readonly ["allow", "deny", "ask", "defer"]>;
declare const HookSpecificOutput_base: Schema.Class<HookSpecificOutput, Schema.Struct<{
    readonly hookEventName: Schema.Literal<"PreToolUse">;
    readonly permissionDecision: Schema.Literals<readonly ["allow", "deny", "ask", "defer"]>;
    readonly permissionDecisionReason: Schema.optional<Schema.String>;
    readonly updatedInput: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
    readonly additionalContext: Schema.optional<Schema.String>;
}>, {}>;
/**
 * `hookSpecificOutput` payload for a PreToolUse hook. This is where the
 * permission decision lives.
 *
 * @category Schemas
 * @since 0.1.0
 */
export declare class HookSpecificOutput extends HookSpecificOutput_base {
}
declare const Output_base: Schema.Class<Output, Schema.Struct<{
    readonly continue: Schema.optional<Schema.Boolean>;
    readonly stopReason: Schema.optional<Schema.String>;
    readonly suppressOutput: Schema.optional<Schema.Boolean>;
    readonly systemMessage: Schema.optional<Schema.String>;
    readonly terminalSequence: Schema.optional<Schema.String>;
    readonly hookSpecificOutput: Schema.optional<typeof HookSpecificOutput>;
}>, {}>;
/**
 * Full PreToolUse hook output, including universal fields.
 *
 * @category Schemas
 * @since 0.1.0
 */
export declare class Output extends Output_base {
}
/**
 * Build an `allow` decision. The tool call proceeds.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const allow: (reason?: string) => Output;
/**
 * Build a no-op output. The tool proceeds through normal permission flow.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const passthrough: () => Output;
/**
 * Build a `deny` decision with a required explanation. The tool call
 * is blocked and the reason is fed back to Claude.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const deny: (reason: string) => Output;
/**
 * Build an `ask` decision. Claude Code shows the user a permission
 * prompt for the tool call.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const ask: (reason?: string) => Output;
/**
 * Build a `defer` decision. In headless mode, Claude Code exits with
 * `stop_reason: "tool_deferred"` so an outer process can resume later.
 * Use `passthrough()` for a neutral no-op.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const defer: (reason?: string) => Output;
/**
 * Build an `allow` decision that replaces the tool input with a
 * modified version.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const allowWithUpdatedInput: (updatedInput: Readonly<Record<string, unknown>>, reason?: string) => Output;
/**
 * Build a runnable PreToolUse hook from a handler effect.
 *
 * @category Constructors
 * @since 0.1.0
 * @example
 * ```ts
 * import * as Effect from 'effect/Effect'
 * import { Hook } from 'effect-claudecode'
 *
 * const hook = Hook.PreToolUse.define({
 *   handler: (input) => Effect.gen(function* () {
 *     if (input.tool_name !== 'Bash') return Hook.PreToolUse.passthrough()
 *     const cmd = (input.tool_input as { command?: string }).command ?? ''
 *     return cmd.includes('rm -rf /')
 *       ? Hook.PreToolUse.deny('destructive')
 *       : Hook.PreToolUse.passthrough()
 *   })
 * })
 *
 * Hook.runMain(hook)
 * ```
 */
export declare const define: (config: {
    readonly handler: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
}) => HookDefinition<Input, Output>;
/**
 * Build a PreToolUse hook that only handles a specific supported tool.
 * Non-matching tool invocations default to `passthrough()`.
 *
 * @category Constructors
 * @since 0.1.0
 */
export type OnToolConfig<T extends Tool.SupportedToolName> = {
    readonly toolName: T;
    readonly handler: (input: Tool.DecodedPreToolUse<T>) => Effect.Effect<Output, unknown, HookContext.Service>;
    readonly onMismatch?: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
    readonly onDecodeError?: (error: HookToolDecodeError, input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
};
export declare const onTool: <const T extends Tool.SupportedToolName>(config: OnToolConfig<T>) => HookDefinition<Input, Output>;
/**
 * Build a PreToolUse hook that only handles matching `tool_name` values.
 * Non-matching tool invocations default to `passthrough()`.
 *
 * @category Constructors
 * @since 0.1.0
 */
export declare const onMatcher: (config: {
    readonly matcher: string | RegExp;
    readonly handler: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
    readonly onMismatch?: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
}) => HookDefinition<Input, Output>;
/**
 * Build a PreToolUse hook from a custom typed tool adapter.
 * Non-matching tool invocations default to `passthrough()`.
 *
 * @category Constructors
 * @since 0.1.0
 */
export declare const onAdapter: <TName extends string, TTool>(config: {
    readonly adapter: Tool.PreToolAdapter<TName, TTool>;
    readonly handler: (input: Tool.DecodedPreToolUseWith<TTool>) => Effect.Effect<Output, unknown, HookContext.Service>;
    readonly onMismatch?: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
    readonly onDecodeError?: (error: HookToolDecodeError, input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
}) => HookDefinition<Input, Output>;
export {};
//# sourceMappingURL=PreToolUse.d.ts.map