/**
 * PostToolUse hook event.
 *
 * Fires after a tool call completes successfully. A handler can block the
 * tool result (feeding feedback back to Claude), inject additional context,
 * or replace the tool's response (for MCP tools). Supports a regex matcher
 * on `tool_name`. See https://code.claude.com/docs/en/hooks#posttooluse.
 *
 * @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<"PostToolUse">;
    readonly tool_name: Schema.String;
    readonly tool_input: Schema.$Record<Schema.String, Schema.Unknown>;
    readonly tool_response: Schema.$Record<Schema.String, Schema.Unknown>;
    readonly tool_use_id: Schema.optional<Schema.String>;
    readonly duration_ms: Schema.optional<Schema.Number>;
    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>;
}>, {}>;
export declare class Input extends Input_base {
}
declare const HookSpecificOutput_base: Schema.Class<HookSpecificOutput, Schema.Struct<{
    readonly hookEventName: Schema.Literal<"PostToolUse">;
    readonly additionalContext: Schema.optional<Schema.String>;
    readonly updatedToolOutput: Schema.optional<Schema.Unknown>;
    readonly updatedMCPToolOutput: Schema.optional<Schema.Unknown>;
}>, {}>;
export declare class HookSpecificOutput extends HookSpecificOutput_base {
}
declare const Output_base: Schema.Class<Output, Schema.Struct<{
    readonly decision: Schema.optional<Schema.Literal<"block">>;
    readonly reason: Schema.optional<Schema.String>;
    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>;
}>, {}>;
export declare class Output extends Output_base {
}
/**
 * No-op output — tool result passes through unchanged.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const passthrough: () => Output;
/**
 * Block the tool result and feed the reason back to Claude.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const block: (reason: string) => Output;
/**
 * Inject additional context into the transcript without blocking.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const addContext: (additionalContext: string) => Output;
/**
 * Replace the MCP tool's response. Only valid for MCP tool invocations.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const replaceOutput: (updatedToolOutput: unknown, additionalContext?: string) => Output;
export declare const replaceMcpOutput: (updatedMCPToolOutput: unknown, additionalContext?: string) => Output;
export declare const define: (config: {
    readonly handler: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
}) => HookDefinition<Input, Output>;
/**
 * Build a PostToolUse 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.DecodedPostToolUse<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 PostToolUse 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 PostToolUse 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, TResponse>(config: {
    readonly adapter: Tool.PostToolAdapter<TName, TTool, TResponse>;
    readonly handler: (input: Tool.DecodedPostToolUseWith<TTool, TResponse>) => 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=PostToolUse.d.ts.map