/**
 * Tool Approval - Human-in-the-Loop Tool Execution
 *
 * Provides utilities for requiring human approval before tool execution.
 * Compatible with AI SDK v6's needsApproval pattern.
 */
import { EventEmitter } from 'events';
/**
 * Tool approval configuration.
 */
export interface ToolApprovalConfig {
    /** Tool name */
    name: string;
    /** Tool description */
    description?: string;
    /** Whether approval is needed - can be boolean or async function */
    needsApproval?: boolean | ((input: unknown) => boolean | Promise<boolean>);
    /** Timeout for approval in ms (default: 5 minutes) */
    approvalTimeout?: number;
    /** Auto-approve patterns (regex or function) */
    autoApprove?: RegExp | ((input: unknown) => boolean);
    /** Auto-deny patterns (regex or function) */
    autoDeny?: RegExp | ((input: unknown) => boolean);
}
/**
 * Tool approval request.
 */
export interface ToolApprovalRequest {
    /** Unique ID for this approval request */
    requestId: string;
    /** Tool invocation ID */
    toolInvocationId: string;
    /** Tool name */
    toolName: string;
    /** Tool input arguments */
    input: unknown;
    /** Timestamp when request was created */
    timestamp: number;
    /** Optional context about why approval is needed */
    reason?: string;
}
/**
 * Tool approval response.
 */
export interface ToolApprovalResponse {
    /** Request ID being responded to */
    requestId: string;
    /** Whether the tool call is approved */
    approved: boolean;
    /** Optional message from approver */
    message?: string;
    /** Who approved/denied (for audit) */
    approver?: string;
    /** Timestamp of response */
    timestamp: number;
}
/**
 * Approval state for tracking pending approvals.
 */
export type ApprovalState = 'pending' | 'approved' | 'denied' | 'timeout' | 'auto-approved' | 'auto-denied';
/**
 * Approval handler function type.
 */
export type ApprovalHandler = (request: ToolApprovalRequest) => Promise<boolean>;
/**
 * Manages tool approval requests and responses.
 *
 * @example Basic usage
 * ```typescript
 * const manager = new ApprovalManager();
 *
 * // Register a handler
 * manager.onApprovalRequest(async (request) => {
 *   console.log(`Tool ${request.toolName} wants to run with:`, request.input);
 *   return await askUser(`Approve ${request.toolName}?`);
 * });
 *
 * // Request approval
 * const approved = await manager.requestApproval({
 *   toolName: 'deleteFile',
 *   input: { path: '/important/file.txt' }
 * });
 * ```
 */
export declare class ApprovalManager extends EventEmitter {
    private pendingRequests;
    private handlers;
    private defaultTimeout;
    private autoApprovePatterns;
    private autoDenyPatterns;
    constructor(options?: {
        defaultTimeout?: number;
    });
    /**
     * Register an approval handler.
     */
    onApprovalRequest(handler: ApprovalHandler): void;
    /**
     * Add auto-approve pattern.
     */
    addAutoApprove(toolName: string | RegExp, inputPattern?: RegExp | ((input: unknown) => boolean)): void;
    /**
     * Add auto-deny pattern.
     */
    addAutoDeny(toolName: string | RegExp, inputPattern?: RegExp | ((input: unknown) => boolean)): void;
    /**
     * Check if a tool call should be auto-approved.
     */
    private checkAutoApprove;
    /**
     * Check if a tool call should be auto-denied.
     */
    private checkAutoDeny;
    /**
     * Request approval for a tool call.
     */
    requestApproval(options: {
        toolInvocationId?: string;
        toolName: string;
        input: unknown;
        reason?: string;
        timeout?: number;
    }): Promise<boolean>;
    /**
     * Respond to an approval request.
     */
    respond(response: ToolApprovalResponse): void;
    /**
     * Get all pending approval requests.
     */
    getPendingRequests(): ToolApprovalRequest[];
    /**
     * Cancel a pending request.
     */
    cancel(requestId: string): void;
    /**
     * Cancel all pending requests.
     */
    cancelAll(): void;
}
/**
 * Get the global approval manager.
 */
export declare function getApprovalManager(): ApprovalManager;
/**
 * Set a custom global approval manager.
 */
export declare function setApprovalManager(manager: ApprovalManager): void;
/**
 * Wrap a tool with approval requirement.
 *
 * @example
 * ```typescript
 * const deleteFile = withApproval({
 *   name: 'deleteFile',
 *   needsApproval: true,
 *   execute: async (args) => {
 *     await fs.unlink(args.path);
 *     return { success: true };
 *   }
 * });
 * ```
 */
export declare function withApproval<TInput, TOutput>(options: {
    name: string;
    description?: string;
    needsApproval?: boolean | ((input: TInput) => boolean | Promise<boolean>);
    execute: (input: TInput) => Promise<TOutput>;
    onDenied?: (input: TInput) => TOutput | Promise<TOutput>;
    approvalManager?: ApprovalManager;
}): (input: TInput) => Promise<TOutput>;
/**
 * Error thrown when tool approval is denied.
 */
export declare class ToolApprovalDeniedError extends Error {
    readonly toolName: string;
    readonly input: unknown;
    constructor(toolName: string, input: unknown);
}
/**
 * Error thrown when tool approval times out.
 */
export declare class ToolApprovalTimeoutError extends Error {
    readonly toolName: string;
    readonly input: unknown;
    constructor(toolName: string, input: unknown);
}
/**
 * Create a CLI-based approval prompt.
 *
 * @example
 * ```typescript
 * const manager = getApprovalManager();
 * manager.onApprovalRequest(createCLIApprovalPrompt());
 * ```
 */
export declare function createCLIApprovalPrompt(options?: {
    /** Custom prompt message */
    promptMessage?: (request: ToolApprovalRequest) => string;
    /** Input stream (default: process.stdin) */
    input?: NodeJS.ReadableStream;
    /** Output stream (default: process.stdout) */
    output?: NodeJS.WritableStream;
}): ApprovalHandler;
/**
 * Common dangerous patterns that should require approval.
 */
export declare const DANGEROUS_PATTERNS: {
    /** File deletion patterns */
    fileDelete: RegExp;
    /** Database destructive patterns */
    dbDestructive: RegExp;
    /** Shell command patterns */
    shellDangerous: RegExp;
    /** Network patterns */
    networkSensitive: RegExp;
};
/**
 * Check if input matches any dangerous pattern.
 */
export declare function isDangerous(input: unknown): boolean;
/**
 * Create a needsApproval function that checks for dangerous patterns.
 */
export declare function createDangerousPatternChecker(additionalPatterns?: RegExp[]): (input: unknown) => boolean;