/**
 * PermissionRequest hook event.
 *
 * Fires when Claude Code is about to show a permission dialog for a tool.
 * A handler can `allow` or `deny` the tool call directly, optionally
 * rewriting the tool input and persisting new permission rules. Supports
 * a matcher on `tool_name`.
 * See https://code.claude.com/docs/en/hooks#permissionrequest.
 *
 * @since 0.1.0
 */
import * as Effect from 'effect/Effect';
import * as Schema from 'effect/Schema';
import type { HookContext } from '../Context.js';
import type { HookDefinition } from '../Runner.js';
declare const PermissionRule_base: Schema.Class<PermissionRule, Schema.Struct<{
    readonly toolName: Schema.String;
    readonly ruleContent: Schema.optional<Schema.String>;
}>, {}>;
/**
 * A pending permission-rule change Claude Code suggests alongside the
 * prompt. The hook handler can accept these in its `updatedPermissions`.
 *
 * @category Schemas
 * @since 0.1.0
 */
export declare class PermissionRule extends PermissionRule_base {
}
declare const PermissionSuggestion_base: Schema.Class<PermissionSuggestion, Schema.Struct<{
    readonly type: Schema.String;
    readonly rules: Schema.optional<Schema.$Array<typeof PermissionRule>>;
    readonly behavior: Schema.optional<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
    readonly destination: Schema.optional<Schema.Literals<readonly ["session", "localSettings", "projectSettings", "userSettings"]>>;
}>, {}>;
export declare class PermissionSuggestion extends PermissionSuggestion_base {
}
declare const Input_base: Schema.Class<Input, Schema.Struct<{
    readonly hook_event_name: Schema.Literal<"PermissionRequest">;
    readonly tool_name: Schema.String;
    readonly tool_input: Schema.$Record<Schema.String, Schema.Unknown>;
    readonly permission_suggestions: Schema.optional<Schema.$Array<typeof PermissionSuggestion>>;
    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 RulePermissionUpdate_base: Schema.Class<RulePermissionUpdate, Schema.Struct<{
    readonly type: Schema.Literals<readonly ["addRules", "replaceRules", "removeRules"]>;
    readonly rules: Schema.$Array<typeof PermissionRule>;
    readonly behavior: Schema.Literals<readonly ["allow", "deny", "ask"]>;
    readonly destination: Schema.Literals<readonly ["session", "localSettings", "projectSettings", "userSettings"]>;
}>, {}>;
/**
 * A permission rule update the hook may persist. Mirrors the shape of
 * `permission_suggestions` on the input side.
 *
 * @category Schemas
 * @since 0.1.0
 */
export declare class RulePermissionUpdate extends RulePermissionUpdate_base {
}
declare const ModePermissionUpdate_base: Schema.Class<ModePermissionUpdate, Schema.Struct<{
    readonly type: Schema.Literal<"setMode">;
    readonly mode: Schema.Literals<readonly ["default", "auto", "acceptEdits", "dontAsk", "bypassPermissions", "plan"]>;
    readonly destination: Schema.Literals<readonly ["session", "localSettings", "projectSettings", "userSettings"]>;
}>, {}>;
export declare class ModePermissionUpdate extends ModePermissionUpdate_base {
}
declare const DirectoryPermissionUpdate_base: Schema.Class<DirectoryPermissionUpdate, Schema.Struct<{
    readonly type: Schema.Literals<readonly ["addDirectories", "removeDirectories"]>;
    readonly directories: Schema.$Array<Schema.String>;
    readonly destination: Schema.Literals<readonly ["session", "localSettings", "projectSettings", "userSettings"]>;
}>, {}>;
export declare class DirectoryPermissionUpdate extends DirectoryPermissionUpdate_base {
}
export declare const PermissionUpdate: Schema.Union<readonly [typeof RulePermissionUpdate, typeof ModePermissionUpdate, typeof DirectoryPermissionUpdate]>;
export type PermissionUpdate = typeof PermissionUpdate.Type;
declare const PermissionDecision_base: Schema.Class<PermissionDecision, Schema.Struct<{
    readonly behavior: Schema.Literals<readonly ["allow", "deny"]>;
    readonly updatedInput: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
    readonly updatedPermissions: Schema.optional<Schema.$Array<Schema.Union<readonly [typeof RulePermissionUpdate, typeof ModePermissionUpdate, typeof DirectoryPermissionUpdate]>>>;
    readonly message: Schema.optional<Schema.String>;
    readonly interrupt: Schema.optional<Schema.Boolean>;
}>, {}>;
export declare class PermissionDecision extends PermissionDecision_base {
}
declare const HookSpecificOutput_base: Schema.Class<HookSpecificOutput, Schema.Struct<{
    readonly hookEventName: Schema.Literal<"PermissionRequest">;
    readonly decision: typeof PermissionDecision;
}>, {}>;
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>;
}>, {}>;
export declare class Output extends Output_base {
}
export declare const allow: (options?: {
    readonly updatedInput?: Readonly<Record<string, unknown>>;
    readonly updatedPermissions?: ReadonlyArray<PermissionUpdate>;
}) => Output;
/**
 * No-op output — Claude Code proceeds with its normal permission request flow.
 *
 * @category Decisions
 * @since 0.1.0
 */
export declare const passthrough: () => Output;
export declare const deny: (message: string, options?: {
    readonly interrupt?: boolean;
}) => Output;
export declare const define: (config: {
    readonly handler: (input: Input) => Effect.Effect<Output, unknown, HookContext.Service>;
}) => HookDefinition<Input, Output>;
/**
 * Build a PermissionRequest hook that only handles matching `tool_name`
 * values.
 *
 * @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>;
export {};
//# sourceMappingURL=PermissionRequest.d.ts.map