/**
 * TypeScript SDK types for Amp CLI
 *
 * These types are compatible with the Amp CLI --stream-json output.
 */
import { z } from 'zod';
/** Text content block containing plain text */
export interface TextContent {
    type: 'text';
    text: string;
}
/** Tool use content block representing a tool call request */
export interface ToolUseContent {
    type: 'tool_use';
    id: string;
    name: string;
    input: Record<string, unknown>;
}
/** Tool result content block containing the result of a tool execution */
export interface ToolResultContent {
    type: 'tool_result';
    tool_use_id: string;
    content: string;
    is_error: boolean;
}
/** Token usage information for API calls */
export interface Usage {
    input_tokens: number;
    cache_creation_input_tokens?: number;
    cache_read_input_tokens?: number;
    output_tokens: number;
    service_tier?: string;
}
/** Base interface for all message types */
interface BaseMessage {
    type: 'system' | 'assistant' | 'user' | 'result';
    session_id: string;
}
/** MCP server connection status */
export type MCPConnectionStatus = 'awaiting-approval' | 'authenticating' | 'connecting' | 'reconnecting' | 'connected' | 'denied' | 'failed' | 'blocked-by-registry';
/** System initialization message containing session info and available tools */
export interface SystemMessage extends BaseMessage {
    type: 'system';
    subtype: 'init';
    cwd: string;
    tools: string[];
    mcp_servers: {
        name: string;
        status: MCPConnectionStatus;
    }[];
}
/** AI assistant response message with text and tool usage */
export interface AssistantMessage extends BaseMessage {
    type: 'assistant';
    message: {
        id: string;
        type: 'message';
        role: 'assistant';
        model: string;
        content: Array<TextContent | ToolUseContent>;
        stop_reason: 'end_turn' | 'tool_use' | 'max_tokens' | null;
        stop_sequence: string | null;
        usage?: Usage;
    };
    parent_tool_use_id: string | null;
}
/** User input message containing text or tool results */
export interface UserMessage extends BaseMessage {
    type: 'user';
    message: {
        role: 'user';
        content: Array<TextContent | ToolResultContent>;
    };
    parent_tool_use_id: string | null;
}
/** Base interface for result messages */
interface BaseResultMessage extends BaseMessage {
    type: 'result';
    duration_ms: number;
    num_turns: number;
    usage?: Usage;
    permission_denials?: string[];
}
/** Successful execution result message */
export interface ResultMessage extends BaseResultMessage {
    subtype: 'success';
    is_error: false;
    result: string;
}
/** Error result message indicating execution failure */
export interface ErrorResultMessage extends BaseResultMessage {
    subtype: 'error_during_execution' | 'error_max_turns';
    is_error: true;
    error: string;
}
/** Union of all possible stream messages */
export type StreamMessage = SystemMessage | AssistantMessage | UserMessage | ResultMessage | ErrorResultMessage;
/** User input message schema */
export declare const UserInputMessage: z.ZodObject<{
    type: z.ZodLiteral<"user">;
    message: z.ZodObject<{
        role: z.ZodLiteral<"user">;
        content: z.ZodArray<z.ZodObject<{
            type: z.ZodLiteral<"text">;
            text: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            text: string;
            type: "text";
        }, {
            text: string;
            type: "text";
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        role: "user";
        content: {
            text: string;
            type: "text";
        }[];
    }, {
        role: "user";
        content: {
            text: string;
            type: "text";
        }[];
    }>;
}, "strip", z.ZodTypeAny, {
    message: {
        role: "user";
        content: {
            text: string;
            type: "text";
        }[];
    };
    type: "user";
}, {
    message: {
        role: "user";
        content: {
            text: string;
            type: "text";
        }[];
    };
    type: "user";
}>;
/** User input message for streaming conversations */
export type UserInputMessage = z.infer<typeof UserInputMessage>;
/** Recursive type for permission match conditions */
export type PermissionMatchCondition = string | PermissionMatchCondition[] | {
    [key in string]: PermissionMatchCondition;
} | boolean | number | null | undefined;
/** Permission match condition for tool arguments schema */
export declare const PermissionMatchConditionSchema: z.ZodType<PermissionMatchCondition>;
/** Individual permission schema */
export declare const Permission: z.ZodEffects<z.ZodObject<{
    tool: z.ZodString;
    matches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<PermissionMatchCondition, z.ZodTypeDef, PermissionMatchCondition>>>;
    action: z.ZodEnum<["allow", "reject", "ask", "delegate"]>;
    context: z.ZodOptional<z.ZodEnum<["thread", "subagent"]>>;
    to: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    tool: string;
    action: "allow" | "reject" | "ask" | "delegate";
    matches?: Record<string, PermissionMatchCondition> | undefined;
    context?: "thread" | "subagent" | undefined;
    to?: string | undefined;
}, {
    tool: string;
    action: "allow" | "reject" | "ask" | "delegate";
    matches?: Record<string, PermissionMatchCondition> | undefined;
    context?: "thread" | "subagent" | undefined;
    to?: string | undefined;
}>, {
    tool: string;
    action: "allow" | "reject" | "ask" | "delegate";
    matches?: Record<string, PermissionMatchCondition> | undefined;
    context?: "thread" | "subagent" | undefined;
    to?: string | undefined;
}, {
    tool: string;
    action: "allow" | "reject" | "ask" | "delegate";
    matches?: Record<string, PermissionMatchCondition> | undefined;
    context?: "thread" | "subagent" | undefined;
    to?: string | undefined;
}>;
/** Permission */
export type Permission = z.infer<typeof Permission>;
/** Permissions list */
export type PermissionsList = Permission[];
/** MCP server configuration schema (stdio or HTTP) */
export declare const MCPServer: z.ZodUnion<[z.ZodObject<{
    command: z.ZodString;
    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    disabled: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    command: string;
    args?: string[] | undefined;
    env?: Record<string, string> | undefined;
    disabled?: boolean | undefined;
}, {
    command: string;
    args?: string[] | undefined;
    env?: Record<string, string> | undefined;
    disabled?: boolean | undefined;
}>, z.ZodObject<{
    url: z.ZodString;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    transport: z.ZodOptional<z.ZodString>;
    oauth: z.ZodOptional<z.ZodObject<{
        clientId: z.ZodString;
        clientSecret: z.ZodOptional<z.ZodString>;
        authUrl: z.ZodString;
        tokenUrl: z.ZodString;
        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        redirectUrl: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    }, {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    }>>;
    disabled: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    url: string;
    disabled?: boolean | undefined;
    headers?: Record<string, string> | undefined;
    transport?: string | undefined;
    oauth?: {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    } | undefined;
}, {
    url: string;
    disabled?: boolean | undefined;
    headers?: Record<string, string> | undefined;
    transport?: string | undefined;
    oauth?: {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    } | undefined;
}>]>;
/** MCP configuration schema */
export declare const MCPConfig: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
    command: z.ZodString;
    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    disabled: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    command: string;
    args?: string[] | undefined;
    env?: Record<string, string> | undefined;
    disabled?: boolean | undefined;
}, {
    command: string;
    args?: string[] | undefined;
    env?: Record<string, string> | undefined;
    disabled?: boolean | undefined;
}>, z.ZodObject<{
    url: z.ZodString;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    transport: z.ZodOptional<z.ZodString>;
    oauth: z.ZodOptional<z.ZodObject<{
        clientId: z.ZodString;
        clientSecret: z.ZodOptional<z.ZodString>;
        authUrl: z.ZodString;
        tokenUrl: z.ZodString;
        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        redirectUrl: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    }, {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    }>>;
    disabled: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    url: string;
    disabled?: boolean | undefined;
    headers?: Record<string, string> | undefined;
    transport?: string | undefined;
    oauth?: {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    } | undefined;
}, {
    url: string;
    disabled?: boolean | undefined;
    headers?: Record<string, string> | undefined;
    transport?: string | undefined;
    oauth?: {
        clientId: string;
        authUrl: string;
        tokenUrl: string;
        clientSecret?: string | undefined;
        scopes?: string[] | undefined;
        redirectUrl?: string | undefined;
    } | undefined;
}>]>>;
/** MCP server configuration (stdio or HTTP) */
export type MCPServer = z.infer<typeof MCPServer>;
/** MCP configuration object */
export type MCPConfig = z.infer<typeof MCPConfig>;
/** Options for creating a new thread schema */
export declare const ThreadsNewOptions: z.ZodObject<{
    visibility: z.ZodOptional<z.ZodEnum<["private", "unlisted", "public", "workspace", "group"]>>;
}, "strip", z.ZodTypeAny, {
    visibility?: "private" | "unlisted" | "public" | "workspace" | "group" | undefined;
}, {
    visibility?: "private" | "unlisted" | "public" | "workspace" | "group" | undefined;
}>;
/** Options for creating a new thread */
export type ThreadsNewOptions = z.infer<typeof ThreadsNewOptions>;
/** Options for getting thread markdown schema */
export declare const ThreadsMarkdownOptions: z.ZodObject<{
    threadId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    threadId: string;
}, {
    threadId: string;
}>;
/** Options for getting thread markdown */
export type ThreadsMarkdownOptions = z.infer<typeof ThreadsMarkdownOptions>;
/** Options for opening or closing a thread for contributions (multiplayer) schema */
export declare const ThreadsSetMultiplayerOptions: z.ZodEffects<z.ZodObject<{
    threadId: z.ZodString;
    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    minutes: z.ZodOptional<z.ZodNumber>;
    hours: z.ZodOptional<z.ZodNumber>;
    days: z.ZodOptional<z.ZodNumber>;
    weeks: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    threadId: string;
    enabled: boolean;
    minutes?: number | undefined;
    hours?: number | undefined;
    days?: number | undefined;
    weeks?: number | undefined;
}, {
    threadId: string;
    minutes?: number | undefined;
    hours?: number | undefined;
    days?: number | undefined;
    weeks?: number | undefined;
    enabled?: boolean | undefined;
}>, {
    threadId: string;
    enabled: boolean;
    minutes?: number | undefined;
    hours?: number | undefined;
    days?: number | undefined;
    weeks?: number | undefined;
}, {
    threadId: string;
    minutes?: number | undefined;
    hours?: number | undefined;
    days?: number | undefined;
    weeks?: number | undefined;
    enabled?: boolean | undefined;
}>;
/** Options for opening or closing a thread for contributions (multiplayer) */
export type ThreadsSetMultiplayerOptions = z.input<typeof ThreadsSetMultiplayerOptions>;
/** Configuration options for Amp execution schema */
export declare const AmpOptionsSchema: z.ZodObject<{
    cwd: z.ZodOptional<z.ZodString>;
    mode: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    effort: z.ZodOptional<z.ZodEnum<["none", "minimal", "low", "medium", "high", "xhigh", "max"]>>;
    dangerouslyAllowAll: z.ZodOptional<z.ZodBoolean>;
    archive: z.ZodOptional<z.ZodBoolean>;
    noArchiveAfterExecute: z.ZodOptional<z.ZodBoolean>;
    visibility: z.ZodOptional<z.ZodDefault<z.ZodEnum<["private", "unlisted", "public", "workspace", "group"]>>>;
    settingsFile: z.ZodOptional<z.ZodString>;
    logLevel: z.ZodOptional<z.ZodEnum<["debug", "info", "warn", "error", "audit"]>>;
    logFile: z.ZodOptional<z.ZodString>;
    mcpConfig: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
        command: z.ZodString;
        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        disabled: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        command: string;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
        disabled?: boolean | undefined;
    }, {
        command: string;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
        disabled?: boolean | undefined;
    }>, z.ZodObject<{
        url: z.ZodString;
        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        transport: z.ZodOptional<z.ZodString>;
        oauth: z.ZodOptional<z.ZodObject<{
            clientId: z.ZodString;
            clientSecret: z.ZodOptional<z.ZodString>;
            authUrl: z.ZodString;
            tokenUrl: z.ZodString;
            scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            redirectUrl: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            clientId: string;
            authUrl: string;
            tokenUrl: string;
            clientSecret?: string | undefined;
            scopes?: string[] | undefined;
            redirectUrl?: string | undefined;
        }, {
            clientId: string;
            authUrl: string;
            tokenUrl: string;
            clientSecret?: string | undefined;
            scopes?: string[] | undefined;
            redirectUrl?: string | undefined;
        }>>;
        disabled: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        url: string;
        disabled?: boolean | undefined;
        headers?: Record<string, string> | undefined;
        transport?: string | undefined;
        oauth?: {
            clientId: string;
            authUrl: string;
            tokenUrl: string;
            clientSecret?: string | undefined;
            scopes?: string[] | undefined;
            redirectUrl?: string | undefined;
        } | undefined;
    }, {
        url: string;
        disabled?: boolean | undefined;
        headers?: Record<string, string> | undefined;
        transport?: string | undefined;
        oauth?: {
            clientId: string;
            authUrl: string;
            tokenUrl: string;
            clientSecret?: string | undefined;
            scopes?: string[] | undefined;
            redirectUrl?: string | undefined;
        } | undefined;
    }>]>>]>>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    continue: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
    skills: z.ZodOptional<z.ZodString>;
    permissions: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
        tool: z.ZodString;
        matches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<PermissionMatchCondition, z.ZodTypeDef, PermissionMatchCondition>>>;
        action: z.ZodEnum<["allow", "reject", "ask", "delegate"]>;
        context: z.ZodOptional<z.ZodEnum<["thread", "subagent"]>>;
        to: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        tool: string;
        action: "allow" | "reject" | "ask" | "delegate";
        matches?: Record<string, PermissionMatchCondition> | undefined;
        context?: "thread" | "subagent" | undefined;
        to?: string | undefined;
    }, {
        tool: string;
        action: "allow" | "reject" | "ask" | "delegate";
        matches?: Record<string, PermissionMatchCondition> | undefined;
        context?: "thread" | "subagent" | undefined;
        to?: string | undefined;
    }>, {
        tool: string;
        action: "allow" | "reject" | "ask" | "delegate";
        matches?: Record<string, PermissionMatchCondition> | undefined;
        context?: "thread" | "subagent" | undefined;
        to?: string | undefined;
    }, {
        tool: string;
        action: "allow" | "reject" | "ask" | "delegate";
        matches?: Record<string, PermissionMatchCondition> | undefined;
        context?: "thread" | "subagent" | undefined;
        to?: string | undefined;
    }>, "many">>;
    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    enabledTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    thinking: z.ZodOptional<z.ZodBoolean>;
    executor: z.ZodOptional<z.ZodEnum<["local", "orb"]>>;
    project: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    mode: string;
    env?: Record<string, string> | undefined;
    visibility?: "private" | "unlisted" | "public" | "workspace" | "group" | undefined;
    cwd?: string | undefined;
    effort?: "max" | "medium" | "none" | "minimal" | "low" | "high" | "xhigh" | undefined;
    dangerouslyAllowAll?: boolean | undefined;
    archive?: boolean | undefined;
    noArchiveAfterExecute?: boolean | undefined;
    settingsFile?: string | undefined;
    logLevel?: "debug" | "info" | "warn" | "error" | "audit" | undefined;
    logFile?: string | undefined;
    mcpConfig?: string | Record<string, {
        command: string;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
        disabled?: boolean | undefined;
    } | {
        url: string;
        disabled?: boolean | undefined;
        headers?: Record<string, string> | undefined;
        transport?: string | undefined;
        oauth?: {
            clientId: string;
            authUrl: string;
            tokenUrl: string;
            clientSecret?: string | undefined;
            scopes?: string[] | undefined;
            redirectUrl?: string | undefined;
        } | undefined;
    }> | undefined;
    continue?: string | boolean | undefined;
    skills?: string | undefined;
    permissions?: {
        tool: string;
        action: "allow" | "reject" | "ask" | "delegate";
        matches?: Record<string, PermissionMatchCondition> | undefined;
        context?: "thread" | "subagent" | undefined;
        to?: string | undefined;
    }[] | undefined;
    labels?: string[] | undefined;
    enabledTools?: string[] | undefined;
    thinking?: boolean | undefined;
    executor?: "local" | "orb" | undefined;
    project?: string | undefined;
}, {
    env?: Record<string, string> | undefined;
    visibility?: "private" | "unlisted" | "public" | "workspace" | "group" | undefined;
    cwd?: string | undefined;
    mode?: string | undefined;
    effort?: "max" | "medium" | "none" | "minimal" | "low" | "high" | "xhigh" | undefined;
    dangerouslyAllowAll?: boolean | undefined;
    archive?: boolean | undefined;
    noArchiveAfterExecute?: boolean | undefined;
    settingsFile?: string | undefined;
    logLevel?: "debug" | "info" | "warn" | "error" | "audit" | undefined;
    logFile?: string | undefined;
    mcpConfig?: string | Record<string, {
        command: string;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
        disabled?: boolean | undefined;
    } | {
        url: string;
        disabled?: boolean | undefined;
        headers?: Record<string, string> | undefined;
        transport?: string | undefined;
        oauth?: {
            clientId: string;
            authUrl: string;
            tokenUrl: string;
            clientSecret?: string | undefined;
            scopes?: string[] | undefined;
            redirectUrl?: string | undefined;
        } | undefined;
    }> | undefined;
    continue?: string | boolean | undefined;
    skills?: string | undefined;
    permissions?: {
        tool: string;
        action: "allow" | "reject" | "ask" | "delegate";
        matches?: Record<string, PermissionMatchCondition> | undefined;
        context?: "thread" | "subagent" | undefined;
        to?: string | undefined;
    }[] | undefined;
    labels?: string[] | undefined;
    enabledTools?: string[] | undefined;
    thinking?: boolean | undefined;
    executor?: "local" | "orb" | undefined;
    project?: string | undefined;
}>;
/** Configuration options for Amp execution */
export type AmpOptions = z.input<typeof AmpOptionsSchema>;
/**
 * Configuration options for Amp execution after schema defaults are applied.
 *
 * Internal SDK helpers use this to work with fully validated options.
 */
export type ResolvedAmpOptions = z.output<typeof AmpOptionsSchema>;
/** Input type for prompts - either a string or streaming user messages */
type PromptInput = string | AsyncIterable<UserInputMessage>;
/** Options for executing Amp commands */
export interface ExecuteOptions {
    prompt: PromptInput;
    options?: AmpOptions;
    signal?: AbortSignal;
}
export {};
//# sourceMappingURL=types.d.ts.map