import * as z from "zod/v3";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
import { DataPart } from "./datapart.js";
import { ErrorPart } from "./errorpart.js";
import { FilePart } from "./filepart.js";
import { TextPart } from "./textpart.js";
import { ToolCallPart } from "./toolcallpart.js";
import { ToolResultPart } from "./toolresultpart.js";
/**
 * Extended A2A message role
 */
export declare const AgentStartedStreamingEventRole: {
    readonly User: "user";
    readonly Agent: "agent";
    readonly Tool: "tool";
    readonly System: "system";
};
/**
 * Extended A2A message role
 */
export type AgentStartedStreamingEventRole = ClosedEnum<typeof AgentStartedStreamingEventRole>;
export type AgentStartedStreamingEventParts = TextPart | ErrorPart | DataPart | FilePart | ToolCallPart | ToolResultPart;
export type InputMessage = {
    messageId?: string | undefined;
    /**
     * Extended A2A message role
     */
    role: AgentStartedStreamingEventRole;
    parts: Array<TextPart | ErrorPart | DataPart | FilePart | ToolCallPart | ToolResultPart>;
    metadata?: {
        [k: string]: any;
    } | undefined;
};
/**
 * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
 */
export declare const ToolApprovalRequired: {
    readonly All: "all";
    readonly RespectTool: "respect_tool";
    readonly None: "none";
};
/**
 * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
 */
export type ToolApprovalRequired = ClosedEnum<typeof ToolApprovalRequired>;
export type AgentStartedStreamingEventConditions = {
    /**
     * The argument of the tool call to evaluate
     */
    condition: string;
    /**
     * The operator to use
     */
    operator: string;
    /**
     * The value to compare against
     */
    value: string;
};
export type Tools = {
    /**
     * The id of the resource
     */
    id: string;
    /**
     * Optional tool key for custom tools
     */
    key?: string | undefined;
    actionType: string;
    displayName?: string | undefined;
    /**
     * Optional tool description
     */
    description?: string | undefined;
    requiresApproval: boolean;
    /**
     * Nested tool ID for MCP tools (identifies specific tool within MCP server)
     */
    toolId?: string | undefined;
    conditions?: Array<AgentStartedStreamingEventConditions> | undefined;
    /**
     * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
     */
    timeout: number;
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export declare const AgentStartedStreamingEventDataExecuteOn: {
    readonly Input: "input";
    readonly Output: "output";
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export type AgentStartedStreamingEventDataExecuteOn = ClosedEnum<typeof AgentStartedStreamingEventDataExecuteOn>;
export type Evaluators = {
    /**
     * Unique key or identifier of the evaluator
     */
    id: string;
    /**
     * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
     */
    sampleRate: number;
    /**
     * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
     */
    executeOn: AgentStartedStreamingEventDataExecuteOn;
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export declare const AgentStartedStreamingEventExecuteOn: {
    readonly Input: "input";
    readonly Output: "output";
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export type AgentStartedStreamingEventExecuteOn = ClosedEnum<typeof AgentStartedStreamingEventExecuteOn>;
export type Guardrails = {
    /**
     * Unique key or identifier of the evaluator
     */
    id: string;
    /**
     * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
     */
    sampleRate: number;
    /**
     * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
     */
    executeOn: AgentStartedStreamingEventExecuteOn;
};
export type Settings = {
    /**
     * Maximum iterations(llm calls) before the agent will stop executing.
     */
    maxIterations: number;
    /**
     * Maximum time (in seconds) for the agent thinking process. This does not include the time for tool calls and sub agent calls. It will be loosely enforced, the in progress LLM calls will not be terminated and the last assistant message will be returned.
     */
    maxExecutionTime: number;
    /**
     * Maximum cost in USD for the agent execution. When the accumulated cost exceeds this limit, the agent will stop executing. Set to 0 for unlimited. Only supported in v3 responses
     */
    maxCost: number;
    /**
     * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
     */
    toolApprovalRequired: ToolApprovalRequired;
    tools?: Array<Tools> | undefined;
    /**
     * Configuration for an evaluator applied to the agent
     */
    evaluators?: Array<Evaluators> | undefined;
    /**
     * Configuration for a guardrail applied to the agent
     */
    guardrails?: Array<Guardrails> | undefined;
};
export declare const AgentSource: {
    readonly Internal: "internal";
    readonly External: "external";
    readonly Experiment: "experiment";
};
export type AgentSource = ClosedEnum<typeof AgentSource>;
export type AgentStartedStreamingEventData = {
    workflowRunId: string;
    integrationId?: string | undefined;
    inputMessage: InputMessage;
    modelId: string;
    instructions: string;
    systemPrompt: string;
    settings?: Settings | undefined;
    agentManifestId: string;
    agentKey: string;
    agentDescription?: string | null | undefined;
    agentSource?: AgentSource | null | undefined;
    variables?: {
        [k: string]: any;
    } | undefined;
    toolExecutionId?: string | undefined;
    isContinuation?: boolean | undefined;
    stream?: boolean | undefined;
    responseId?: string | undefined;
};
/**
 * Emitted when the agent begins processing. Contains configuration details including the model, instructions, system prompt, and input message.
 */
export type AgentStartedStreamingEvent = {
    type: "event.agents.started";
    /**
     * ISO timestamp of the event
     */
    timestamp: string;
    data: AgentStartedStreamingEventData;
};
/** @internal */
export declare const AgentStartedStreamingEventRole$inboundSchema: z.ZodNativeEnum<typeof AgentStartedStreamingEventRole>;
/** @internal */
export declare const AgentStartedStreamingEventParts$inboundSchema: z.ZodType<AgentStartedStreamingEventParts, z.ZodTypeDef, unknown>;
export declare function agentStartedStreamingEventPartsFromJSON(jsonString: string): SafeParseResult<AgentStartedStreamingEventParts, SDKValidationError>;
/** @internal */
export declare const InputMessage$inboundSchema: z.ZodType<InputMessage, z.ZodTypeDef, unknown>;
export declare function inputMessageFromJSON(jsonString: string): SafeParseResult<InputMessage, SDKValidationError>;
/** @internal */
export declare const ToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof ToolApprovalRequired>;
/** @internal */
export declare const AgentStartedStreamingEventConditions$inboundSchema: z.ZodType<AgentStartedStreamingEventConditions, z.ZodTypeDef, unknown>;
export declare function agentStartedStreamingEventConditionsFromJSON(jsonString: string): SafeParseResult<AgentStartedStreamingEventConditions, SDKValidationError>;
/** @internal */
export declare const Tools$inboundSchema: z.ZodType<Tools, z.ZodTypeDef, unknown>;
export declare function toolsFromJSON(jsonString: string): SafeParseResult<Tools, SDKValidationError>;
/** @internal */
export declare const AgentStartedStreamingEventDataExecuteOn$inboundSchema: z.ZodNativeEnum<typeof AgentStartedStreamingEventDataExecuteOn>;
/** @internal */
export declare const Evaluators$inboundSchema: z.ZodType<Evaluators, z.ZodTypeDef, unknown>;
export declare function evaluatorsFromJSON(jsonString: string): SafeParseResult<Evaluators, SDKValidationError>;
/** @internal */
export declare const AgentStartedStreamingEventExecuteOn$inboundSchema: z.ZodNativeEnum<typeof AgentStartedStreamingEventExecuteOn>;
/** @internal */
export declare const Guardrails$inboundSchema: z.ZodType<Guardrails, z.ZodTypeDef, unknown>;
export declare function guardrailsFromJSON(jsonString: string): SafeParseResult<Guardrails, SDKValidationError>;
/** @internal */
export declare const Settings$inboundSchema: z.ZodType<Settings, z.ZodTypeDef, unknown>;
export declare function settingsFromJSON(jsonString: string): SafeParseResult<Settings, SDKValidationError>;
/** @internal */
export declare const AgentSource$inboundSchema: z.ZodNativeEnum<typeof AgentSource>;
/** @internal */
export declare const AgentStartedStreamingEventData$inboundSchema: z.ZodType<AgentStartedStreamingEventData, z.ZodTypeDef, unknown>;
export declare function agentStartedStreamingEventDataFromJSON(jsonString: string): SafeParseResult<AgentStartedStreamingEventData, SDKValidationError>;
/** @internal */
export declare const AgentStartedStreamingEvent$inboundSchema: z.ZodType<AgentStartedStreamingEvent, z.ZodTypeDef, unknown>;
export declare function agentStartedStreamingEventFromJSON(jsonString: string): SafeParseResult<AgentStartedStreamingEvent, SDKValidationError>;
//# sourceMappingURL=agentstartedstreamingevent.d.ts.map