import * as z from "zod/v3";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import * as components from "../components/index.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
export type RetrieveAgentRequestRequest = {
    /**
     * The unique key of the agent to retrieve
     */
    agentKey: string;
};
/**
 * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const RetrieveAgentRequestStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type RetrieveAgentRequestStatus = ClosedEnum<typeof RetrieveAgentRequestStatus>;
export type RetrieveAgentRequestTeamOfAgents = {
    /**
     * The unique key of the agent within the workspace
     */
    key: string;
    /**
     * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
     */
    role?: string | undefined;
};
export type RetrieveAgentRequestMetrics = {
    totalCost: number;
};
export type RetrieveAgentRequestKnowledgeBases = {
    /**
     * Unique identifier of the knowledge base to search
     */
    knowledgeId: string;
};
export declare const RetrieveAgentRequestSource: {
    readonly Internal: "internal";
    readonly External: "external";
    readonly Experiment: "experiment";
};
export type RetrieveAgentRequestSource = ClosedEnum<typeof RetrieveAgentRequestSource>;
/**
 * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
 */
export declare const RetrieveAgentRequestType: {
    readonly Internal: "internal";
    readonly A2a: "a2a";
};
/**
 * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
 */
export type RetrieveAgentRequestType = ClosedEnum<typeof RetrieveAgentRequestType>;
/**
 * 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 RetrieveAgentRequestToolApprovalRequired: {
    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 RetrieveAgentRequestToolApprovalRequired = ClosedEnum<typeof RetrieveAgentRequestToolApprovalRequired>;
export type RetrieveAgentRequestConditions = {
    /**
     * 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 RetrieveAgentRequestTools = {
    /**
     * 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<RetrieveAgentRequestConditions> | 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 RetrieveAgentRequestExecuteOn: {
    readonly Input: "input";
    readonly Output: "output";
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export type RetrieveAgentRequestExecuteOn = ClosedEnum<typeof RetrieveAgentRequestExecuteOn>;
export type RetrieveAgentRequestEvaluators = {
    /**
     * 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: RetrieveAgentRequestExecuteOn;
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export declare const RetrieveAgentRequestAgentsExecuteOn: {
    readonly Input: "input";
    readonly Output: "output";
};
/**
 * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
 */
export type RetrieveAgentRequestAgentsExecuteOn = ClosedEnum<typeof RetrieveAgentRequestAgentsExecuteOn>;
export type RetrieveAgentRequestGuardrails = {
    /**
     * 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: RetrieveAgentRequestAgentsExecuteOn;
};
export type RetrieveAgentRequestSettings = {
    /**
     * 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: RetrieveAgentRequestToolApprovalRequired;
    tools?: Array<RetrieveAgentRequestTools> | undefined;
    /**
     * Configuration for an evaluator applied to the agent
     */
    evaluators?: Array<RetrieveAgentRequestEvaluators> | undefined;
    /**
     * Configuration for a guardrail applied to the agent
     */
    guardrails?: Array<RetrieveAgentRequestGuardrails> | undefined;
};
export type RetrieveAgentRequestResponseFormatJsonSchema = {
    /**
     * A description of what the response format is for, used by the model to determine how to respond in the format.
     */
    description?: string | undefined;
    /**
     * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
     */
    name: string;
    /**
     * The schema for the response format, described as a JSON Schema object.
     */
    schema?: any | undefined;
    /**
     * Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true.
     */
    strict: boolean;
};
/**
 * @remarks
 *
 * JSON Schema response format. Used to generate structured JSON responses
 */
export type RetrieveAgentRequestResponseFormatAgentsJSONSchema = {
    type: "json_schema";
    jsonSchema: RetrieveAgentRequestResponseFormatJsonSchema;
};
/**
 * @remarks
 *
 * JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
 */
export type RetrieveAgentRequestResponseFormatJSONObject = {
    type: "json_object";
};
/**
 * @remarks
 *
 * Default response format. Used to generate text responses
 */
export type RetrieveAgentRequestResponseFormatText = {
    type: "text";
};
/**
 * An object specifying the format that the model must output
 */
export type RetrieveAgentRequestResponseFormat = RetrieveAgentRequestResponseFormatText | RetrieveAgentRequestResponseFormatJSONObject | RetrieveAgentRequestResponseFormatAgentsJSONSchema;
/**
 * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 *
 * @remarks
 *
 * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
 * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
 * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 *
 * Any of "none", "minimal", "low", "medium", "high", "xhigh".
 */
export declare const RetrieveAgentRequestReasoningEffort: {
    readonly None: "none";
    readonly Minimal: "minimal";
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
    readonly Xhigh: "xhigh";
};
/**
 * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 *
 * @remarks
 *
 * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
 * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
 * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 *
 * Any of "none", "minimal", "low", "medium", "high", "xhigh".
 */
export type RetrieveAgentRequestReasoningEffort = ClosedEnum<typeof RetrieveAgentRequestReasoningEffort>;
/**
 * Up to 4 sequences where the API will stop generating further tokens.
 */
export type RetrieveAgentRequestStop = string | Array<string>;
export type RetrieveAgentRequestThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | components.ThinkingConfigAdaptiveSchema;
/**
 * The type of the tool. Currently, only function is supported.
 */
export declare const RetrieveAgentRequestToolChoiceType: {
    readonly Function: "function";
};
/**
 * The type of the tool. Currently, only function is supported.
 */
export type RetrieveAgentRequestToolChoiceType = ClosedEnum<typeof RetrieveAgentRequestToolChoiceType>;
export type RetrieveAgentRequestToolChoiceFunction = {
    /**
     * The name of the function to call.
     */
    name: string;
};
export type RetrieveAgentRequestToolChoice2 = {
    /**
     * The type of the tool. Currently, only function is supported.
     */
    type?: RetrieveAgentRequestToolChoiceType | undefined;
    function: RetrieveAgentRequestToolChoiceFunction;
};
export declare const RetrieveAgentRequestToolChoice1: {
    readonly None: "none";
    readonly Auto: "auto";
    readonly Required: "required";
};
export type RetrieveAgentRequestToolChoice1 = ClosedEnum<typeof RetrieveAgentRequestToolChoice1>;
/**
 * Controls which (if any) tool is called by the model.
 */
export type RetrieveAgentRequestToolChoice = RetrieveAgentRequestToolChoice2 | RetrieveAgentRequestToolChoice1;
export declare const RetrieveAgentRequestModalities: {
    readonly Text: "text";
    readonly Audio: "audio";
};
export type RetrieveAgentRequestModalities = ClosedEnum<typeof RetrieveAgentRequestModalities>;
/**
 * The key of the guardrail.
 */
export declare const RetrieveAgentRequestId1: {
    readonly OrqPiiDetection: "orq_pii_detection";
    readonly OrqSexualModeration: "orq_sexual_moderation";
    readonly OrqHarmfulModeration: "orq_harmful_moderation";
};
/**
 * The key of the guardrail.
 */
export type RetrieveAgentRequestId1 = ClosedEnum<typeof RetrieveAgentRequestId1>;
export type RetrieveAgentRequestId = RetrieveAgentRequestId1 | string;
/**
 * Determines whether the guardrail runs on the input (user message) or output (model response).
 */
export declare const RetrieveAgentRequestAgentsResponseExecuteOn: {
    readonly Input: "input";
    readonly Output: "output";
};
/**
 * Determines whether the guardrail runs on the input (user message) or output (model response).
 */
export type RetrieveAgentRequestAgentsResponseExecuteOn = ClosedEnum<typeof RetrieveAgentRequestAgentsResponseExecuteOn>;
export type RetrieveAgentRequestAgentsGuardrails = {
    id: RetrieveAgentRequestId1 | string;
    /**
     * Determines whether the guardrail runs on the input (user message) or output (model response).
     */
    executeOn: RetrieveAgentRequestAgentsResponseExecuteOn;
};
export type RetrieveAgentRequestFallbacks = {
    /**
     * Fallback model identifier
     */
    model: string;
};
export declare const RetrieveAgentRequestAgentsType: {
    readonly ExactMatch: "exact_match";
};
export type RetrieveAgentRequestAgentsType = ClosedEnum<typeof RetrieveAgentRequestAgentsType>;
/**
 * Cache configuration for the request.
 */
export type RetrieveAgentRequestCache = {
    /**
     * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
     */
    ttl: number;
    type: RetrieveAgentRequestAgentsType;
};
export declare const RetrieveAgentRequestLoadBalancerType: {
    readonly WeightBased: "weight_based";
};
export type RetrieveAgentRequestLoadBalancerType = ClosedEnum<typeof RetrieveAgentRequestLoadBalancerType>;
export type RetrieveAgentRequestLoadBalancerModels = {
    /**
     * Model identifier for load balancing
     */
    model: string;
    /**
     * Weight assigned to this model for load balancing
     */
    weight: number;
};
export type RetrieveAgentRequestLoadBalancer1 = {
    type: RetrieveAgentRequestLoadBalancerType;
    models: Array<RetrieveAgentRequestLoadBalancerModels>;
};
/**
 * Load balancer configuration for the request.
 */
export type RetrieveAgentRequestLoadBalancer = RetrieveAgentRequestLoadBalancer1;
/**
 * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
 */
export type RetrieveAgentRequestTimeout = {
    /**
     * Timeout value in milliseconds
     */
    callTimeout: number;
};
/**
 * Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults.
 */
export type RetrieveAgentRequestParameters = {
    /**
     * The name to display on the trace. If not specified, the default system name will be used.
     */
    name?: string | undefined;
    /**
     * Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
     */
    frequencyPenalty?: number | null | undefined;
    /**
     * `[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
     *
     * @remarks
     *
     *  This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
     */
    maxTokens?: number | null | undefined;
    /**
     * An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens
     */
    maxCompletionTokens?: number | null | undefined;
    /**
     * Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
     */
    presencePenalty?: number | null | undefined;
    /**
     * An object specifying the format that the model must output
     */
    responseFormat?: RetrieveAgentRequestResponseFormatText | RetrieveAgentRequestResponseFormatJSONObject | RetrieveAgentRequestResponseFormatAgentsJSONSchema | undefined;
    /**
     * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
     *
     * @remarks
     *
     * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
     * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
     * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
     *
     * Any of "none", "minimal", "low", "medium", "high", "xhigh".
     */
    reasoningEffort?: RetrieveAgentRequestReasoningEffort | undefined;
    /**
     * Adjusts response verbosity. Lower levels yield shorter answers.
     */
    verbosity?: string | undefined;
    /**
     * If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result.
     */
    seed?: number | null | undefined;
    /**
     * Up to 4 sequences where the API will stop generating further tokens.
     */
    stop?: string | Array<string> | null | undefined;
    thinking?: components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | components.ThinkingConfigAdaptiveSchema | undefined;
    /**
     * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
     */
    temperature?: number | null | undefined;
    /**
     * An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
     */
    topP?: number | null | undefined;
    /**
     * Limits the model to consider only the top k most likely tokens at each step.
     */
    topK?: number | null | undefined;
    /**
     * Controls which (if any) tool is called by the model.
     */
    toolChoice?: RetrieveAgentRequestToolChoice2 | RetrieveAgentRequestToolChoice1 | undefined;
    /**
     * Whether to enable parallel function calling during tool use.
     */
    parallelToolCalls?: boolean | undefined;
    /**
     * Output types that you would like the model to generate. Most models are capable of generating text, which is the default: ["text"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: ["text", "audio"].
     */
    modalities?: Array<RetrieveAgentRequestModalities> | null | undefined;
    /**
     * A list of guardrails to apply to the request.
     */
    guardrails?: Array<RetrieveAgentRequestAgentsGuardrails> | undefined;
    /**
     * Array of fallback models to use if primary model fails
     */
    fallbacks?: Array<RetrieveAgentRequestFallbacks> | undefined;
    /**
     * Cache configuration for the request.
     */
    cache?: RetrieveAgentRequestCache | undefined;
    /**
     * Load balancer configuration for the request.
     */
    loadBalancer?: RetrieveAgentRequestLoadBalancer1 | undefined;
    /**
     * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
     */
    timeout?: RetrieveAgentRequestTimeout | undefined;
};
/**
 * Retry configuration for model requests. Allows customizing retry count (1-5) and HTTP status codes that trigger retries. Default codes: [429]. Common codes: 500 (internal error), 429 (rate limit), 502/503/504 (gateway errors).
 */
export type RetrieveAgentRequestRetry = {
    /**
     * Number of retry attempts (1-5)
     */
    count: number;
    /**
     * HTTP status codes that trigger retry logic
     */
    onCodes?: Array<number> | undefined;
};
export type RetrieveAgentRequestResponseFormatAgentsResponseJsonSchema = {
    /**
     * A description of what the response format is for, used by the model to determine how to respond in the format.
     */
    description?: string | undefined;
    /**
     * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
     */
    name: string;
    /**
     * The schema for the response format, described as a JSON Schema object.
     */
    schema?: any | undefined;
    /**
     * Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true.
     */
    strict: boolean;
};
/**
 * @remarks
 *
 * JSON Schema response format. Used to generate structured JSON responses
 */
export type RetrieveAgentRequestResponseFormatAgentsResponse200JSONSchema = {
    type: "json_schema";
    jsonSchema: RetrieveAgentRequestResponseFormatAgentsResponseJsonSchema;
};
/**
 * @remarks
 *
 * JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
 */
export type RetrieveAgentRequestResponseFormatAgentsJSONObject = {
    type: "json_object";
};
/**
 * @remarks
 *
 * Default response format. Used to generate text responses
 */
export type RetrieveAgentRequestResponseFormatAgentsText = {
    type: "text";
};
/**
 * An object specifying the format that the model must output
 */
export type RetrieveAgentRequestFallbackModelConfigurationResponseFormat = RetrieveAgentRequestResponseFormatAgentsText | RetrieveAgentRequestResponseFormatAgentsJSONObject | RetrieveAgentRequestResponseFormatAgentsResponse200JSONSchema;
/**
 * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 *
 * @remarks
 *
 * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
 * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
 * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 *
 * Any of "none", "minimal", "low", "medium", "high", "xhigh".
 */
export declare const RetrieveAgentRequestFallbackModelConfigurationReasoningEffort: {
    readonly None: "none";
    readonly Minimal: "minimal";
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
    readonly Xhigh: "xhigh";
};
/**
 * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 *
 * @remarks
 *
 * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
 * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
 * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 *
 * Any of "none", "minimal", "low", "medium", "high", "xhigh".
 */
export type RetrieveAgentRequestFallbackModelConfigurationReasoningEffort = ClosedEnum<typeof RetrieveAgentRequestFallbackModelConfigurationReasoningEffort>;
/**
 * Up to 4 sequences where the API will stop generating further tokens.
 */
export type RetrieveAgentRequestFallbackModelConfigurationStop = string | Array<string>;
export type RetrieveAgentRequestFallbackModelConfigurationThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | components.ThinkingConfigAdaptiveSchema;
/**
 * The type of the tool. Currently, only function is supported.
 */
export declare const RetrieveAgentRequestToolChoiceAgentsType: {
    readonly Function: "function";
};
/**
 * The type of the tool. Currently, only function is supported.
 */
export type RetrieveAgentRequestToolChoiceAgentsType = ClosedEnum<typeof RetrieveAgentRequestToolChoiceAgentsType>;
export type RetrieveAgentRequestToolChoiceAgentsFunction = {
    /**
     * The name of the function to call.
     */
    name: string;
};
export type RetrieveAgentRequestToolChoiceAgents2 = {
    /**
     * The type of the tool. Currently, only function is supported.
     */
    type?: RetrieveAgentRequestToolChoiceAgentsType | undefined;
    function: RetrieveAgentRequestToolChoiceAgentsFunction;
};
export declare const RetrieveAgentRequestToolChoiceAgents1: {
    readonly None: "none";
    readonly Auto: "auto";
    readonly Required: "required";
};
export type RetrieveAgentRequestToolChoiceAgents1 = ClosedEnum<typeof RetrieveAgentRequestToolChoiceAgents1>;
/**
 * Controls which (if any) tool is called by the model.
 */
export type RetrieveAgentRequestFallbackModelConfigurationToolChoice = RetrieveAgentRequestToolChoiceAgents2 | RetrieveAgentRequestToolChoiceAgents1;
export declare const RetrieveAgentRequestFallbackModelConfigurationModalities: {
    readonly Text: "text";
    readonly Audio: "audio";
};
export type RetrieveAgentRequestFallbackModelConfigurationModalities = ClosedEnum<typeof RetrieveAgentRequestFallbackModelConfigurationModalities>;
/**
 * The key of the guardrail.
 */
export declare const RetrieveAgentRequestIdAgents1: {
    readonly OrqPiiDetection: "orq_pii_detection";
    readonly OrqSexualModeration: "orq_sexual_moderation";
    readonly OrqHarmfulModeration: "orq_harmful_moderation";
};
/**
 * The key of the guardrail.
 */
export type RetrieveAgentRequestIdAgents1 = ClosedEnum<typeof RetrieveAgentRequestIdAgents1>;
export type RetrieveAgentRequestFallbackModelConfigurationId = RetrieveAgentRequestIdAgents1 | string;
/**
 * Determines whether the guardrail runs on the input (user message) or output (model response).
 */
export declare const RetrieveAgentRequestFallbackModelConfigurationExecuteOn: {
    readonly Input: "input";
    readonly Output: "output";
};
/**
 * Determines whether the guardrail runs on the input (user message) or output (model response).
 */
export type RetrieveAgentRequestFallbackModelConfigurationExecuteOn = ClosedEnum<typeof RetrieveAgentRequestFallbackModelConfigurationExecuteOn>;
export type RetrieveAgentRequestFallbackModelConfigurationGuardrails = {
    id: RetrieveAgentRequestIdAgents1 | string;
    /**
     * Determines whether the guardrail runs on the input (user message) or output (model response).
     */
    executeOn: RetrieveAgentRequestFallbackModelConfigurationExecuteOn;
};
export type RetrieveAgentRequestFallbackModelConfigurationFallbacks = {
    /**
     * Fallback model identifier
     */
    model: string;
};
export declare const RetrieveAgentRequestFallbackModelConfigurationType: {
    readonly ExactMatch: "exact_match";
};
export type RetrieveAgentRequestFallbackModelConfigurationType = ClosedEnum<typeof RetrieveAgentRequestFallbackModelConfigurationType>;
/**
 * Cache configuration for the request.
 */
export type RetrieveAgentRequestFallbackModelConfigurationCache = {
    /**
     * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
     */
    ttl: number;
    type: RetrieveAgentRequestFallbackModelConfigurationType;
};
export declare const RetrieveAgentRequestLoadBalancerAgentsType: {
    readonly WeightBased: "weight_based";
};
export type RetrieveAgentRequestLoadBalancerAgentsType = ClosedEnum<typeof RetrieveAgentRequestLoadBalancerAgentsType>;
export type RetrieveAgentRequestLoadBalancerAgentsModels = {
    /**
     * Model identifier for load balancing
     */
    model: string;
    /**
     * Weight assigned to this model for load balancing
     */
    weight: number;
};
export type RetrieveAgentRequestLoadBalancerAgents1 = {
    type: RetrieveAgentRequestLoadBalancerAgentsType;
    models: Array<RetrieveAgentRequestLoadBalancerAgentsModels>;
};
/**
 * Load balancer configuration for the request.
 */
export type RetrieveAgentRequestFallbackModelConfigurationLoadBalancer = RetrieveAgentRequestLoadBalancerAgents1;
/**
 * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
 */
export type RetrieveAgentRequestFallbackModelConfigurationTimeout = {
    /**
     * Timeout value in milliseconds
     */
    callTimeout: number;
};
/**
 * Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used.
 */
export type RetrieveAgentRequestFallbackModelConfigurationParameters = {
    /**
     * The name to display on the trace. If not specified, the default system name will be used.
     */
    name?: string | undefined;
    /**
     * Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
     */
    frequencyPenalty?: number | null | undefined;
    /**
     * `[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
     *
     * @remarks
     *
     *  This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
     */
    maxTokens?: number | null | undefined;
    /**
     * An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens
     */
    maxCompletionTokens?: number | null | undefined;
    /**
     * Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
     */
    presencePenalty?: number | null | undefined;
    /**
     * An object specifying the format that the model must output
     */
    responseFormat?: RetrieveAgentRequestResponseFormatAgentsText | RetrieveAgentRequestResponseFormatAgentsJSONObject | RetrieveAgentRequestResponseFormatAgentsResponse200JSONSchema | undefined;
    /**
     * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
     *
     * @remarks
     *
     * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
     * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
     * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
     *
     * Any of "none", "minimal", "low", "medium", "high", "xhigh".
     */
    reasoningEffort?: RetrieveAgentRequestFallbackModelConfigurationReasoningEffort | undefined;
    /**
     * Adjusts response verbosity. Lower levels yield shorter answers.
     */
    verbosity?: string | undefined;
    /**
     * If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result.
     */
    seed?: number | null | undefined;
    /**
     * Up to 4 sequences where the API will stop generating further tokens.
     */
    stop?: string | Array<string> | null | undefined;
    thinking?: components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | components.ThinkingConfigAdaptiveSchema | undefined;
    /**
     * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
     */
    temperature?: number | null | undefined;
    /**
     * An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
     */
    topP?: number | null | undefined;
    /**
     * Limits the model to consider only the top k most likely tokens at each step.
     */
    topK?: number | null | undefined;
    /**
     * Controls which (if any) tool is called by the model.
     */
    toolChoice?: RetrieveAgentRequestToolChoiceAgents2 | RetrieveAgentRequestToolChoiceAgents1 | undefined;
    /**
     * Whether to enable parallel function calling during tool use.
     */
    parallelToolCalls?: boolean | undefined;
    /**
     * Output types that you would like the model to generate. Most models are capable of generating text, which is the default: ["text"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: ["text", "audio"].
     */
    modalities?: Array<RetrieveAgentRequestFallbackModelConfigurationModalities> | null | undefined;
    /**
     * A list of guardrails to apply to the request.
     */
    guardrails?: Array<RetrieveAgentRequestFallbackModelConfigurationGuardrails> | undefined;
    /**
     * Array of fallback models to use if primary model fails
     */
    fallbacks?: Array<RetrieveAgentRequestFallbackModelConfigurationFallbacks> | undefined;
    /**
     * Cache configuration for the request.
     */
    cache?: RetrieveAgentRequestFallbackModelConfigurationCache | undefined;
    /**
     * Load balancer configuration for the request.
     */
    loadBalancer?: RetrieveAgentRequestLoadBalancerAgents1 | undefined;
    /**
     * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
     */
    timeout?: RetrieveAgentRequestFallbackModelConfigurationTimeout | undefined;
};
/**
 * Retry configuration for this fallback model. Allows customizing retry count (1-5) and HTTP status codes that trigger retries.
 */
export type RetrieveAgentRequestFallbackModelConfigurationRetry = {
    /**
     * Number of retry attempts (1-5)
     */
    count: number;
    /**
     * HTTP status codes that trigger retry logic
     */
    onCodes?: Array<number> | undefined;
};
/**
 * Fallback model configuration with optional parameters and retry settings.
 */
export type RetrieveAgentRequestFallbackModelConfiguration2 = {
    /**
     * A fallback model ID string. Must support tool calling.
     */
    id: string;
    /**
     * Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used.
     */
    parameters?: RetrieveAgentRequestFallbackModelConfigurationParameters | undefined;
    /**
     * Retry configuration for this fallback model. Allows customizing retry count (1-5) and HTTP status codes that trigger retries.
     */
    retry?: RetrieveAgentRequestFallbackModelConfigurationRetry | undefined;
};
/**
 * Fallback model for automatic failover when primary model request fails. Supports optional parameter overrides. Can be a simple model ID string or a configuration object with model-specific parameters. Fallbacks are tried in order.
 */
export type RetrieveAgentRequestFallbackModelConfiguration = RetrieveAgentRequestFallbackModelConfiguration2 | string;
export type RetrieveAgentRequestModel = {
    /**
     * The database ID of the primary model
     */
    id: string;
    /**
     * Optional integration ID for custom model configurations
     */
    integrationId?: string | null | undefined;
    /**
     * Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults.
     */
    parameters?: RetrieveAgentRequestParameters | undefined;
    /**
     * Retry configuration for model requests. Allows customizing retry count (1-5) and HTTP status codes that trigger retries. Default codes: [429]. Common codes: 500 (internal error), 429 (rate limit), 502/503/504 (gateway errors).
     */
    retry?: RetrieveAgentRequestRetry | undefined;
    /**
     * Optional array of fallback models (string IDs or config objects) that will be used automatically in order if the primary model fails
     */
    fallbackModels?: Array<RetrieveAgentRequestFallbackModelConfiguration2 | string> | null | undefined;
};
export type RetrieveAgentRequestHeaders = {
    /**
     * Header value. **Update behavior**: Provide empty string ("") to preserve existing encrypted value without re-entering credentials. Provide new value to rotate. Omit header entirely to remove.
     */
    value: string;
    encrypted: boolean;
};
/**
 * A2A configuration with agent endpoint and authentication. Only present for A2A agents.
 */
export type RetrieveAgentRequestA2AAgentConfiguration = {
    /**
     * The A2A agent endpoint URL (e.g., https://example.com/agent/a2a)
     */
    agentUrl: string;
    /**
     * Optional explicit URL to fetch agent card. Defaults to {agent_url}/card if not provided
     */
    cardUrl?: string | undefined;
    /**
     * HTTP headers for A2A agent requests with encryption support (max 20 headers). **Update behavior**: Empty string values preserve existing encrypted headers, allowing partial updates without credential re-entry.
     */
    headers?: {
        [k: string]: RetrieveAgentRequestHeaders;
    } | undefined;
    /**
     * Cached agent card from discovery. Refreshed periodically.
     */
    cachedCard?: any | undefined;
};
/**
 * Agent successfully retrieved. Returns the complete agent manifest with all configuration details, including models, tools, knowledge bases, and execution settings.
 */
export type RetrieveAgentRequestResponseBody = {
    id: string;
    /**
     * Unique identifier for the agent within the workspace
     */
    key: string;
    displayName?: string | undefined;
    projectId: string;
    createdById?: string | null | undefined;
    updatedById?: string | null | undefined;
    created?: string | undefined;
    updated?: string | undefined;
    /**
     * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: RetrieveAgentRequestStatus;
    /**
     * Current semantic version of the agent manifest.
     */
    version?: string | undefined;
    versionHash?: string | undefined;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Array of memory store identifiers. Accepts both memory store IDs and keys.
     */
    memoryStores?: Array<string> | undefined;
    /**
     * The agents that are accessible to this orchestrator. The main agent can hand off to these agents to perform tasks.
     */
    teamOfAgents?: Array<RetrieveAgentRequestTeamOfAgents> | undefined;
    metrics?: RetrieveAgentRequestMetrics | undefined;
    /**
     * Extracted variables from agent instructions
     */
    variables?: {
        [k: string]: any;
    } | undefined;
    /**
     * Agent knowledge bases reference
     */
    knowledgeBases?: Array<RetrieveAgentRequestKnowledgeBases> | undefined;
    source?: RetrieveAgentRequestSource | undefined;
    /**
     * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
     */
    type: RetrieveAgentRequestType;
    role: string;
    description: string;
    systemPrompt?: string | undefined;
    instructions: string;
    settings?: RetrieveAgentRequestSettings | undefined;
    model: RetrieveAgentRequestModel;
    /**
     * A2A configuration with agent endpoint and authentication. Only present for A2A agents.
     */
    a2a?: RetrieveAgentRequestA2AAgentConfiguration | undefined;
};
/** @internal */
export type RetrieveAgentRequestRequest$Outbound = {
    agent_key: string;
};
/** @internal */
export declare const RetrieveAgentRequestRequest$outboundSchema: z.ZodType<RetrieveAgentRequestRequest$Outbound, z.ZodTypeDef, RetrieveAgentRequestRequest>;
export declare function retrieveAgentRequestRequestToJSON(retrieveAgentRequestRequest: RetrieveAgentRequestRequest): string;
/** @internal */
export declare const RetrieveAgentRequestStatus$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestStatus>;
/** @internal */
export declare const RetrieveAgentRequestTeamOfAgents$inboundSchema: z.ZodType<RetrieveAgentRequestTeamOfAgents, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestTeamOfAgents, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestMetrics$inboundSchema: z.ZodType<RetrieveAgentRequestMetrics, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestMetricsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestMetrics, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestKnowledgeBases$inboundSchema: z.ZodType<RetrieveAgentRequestKnowledgeBases, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestKnowledgeBases, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestSource$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestSource>;
/** @internal */
export declare const RetrieveAgentRequestType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestType>;
/** @internal */
export declare const RetrieveAgentRequestToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestToolApprovalRequired>;
/** @internal */
export declare const RetrieveAgentRequestConditions$inboundSchema: z.ZodType<RetrieveAgentRequestConditions, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestConditionsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestConditions, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestTools$inboundSchema: z.ZodType<RetrieveAgentRequestTools, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestToolsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestTools, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestExecuteOn$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestExecuteOn>;
/** @internal */
export declare const RetrieveAgentRequestEvaluators$inboundSchema: z.ZodType<RetrieveAgentRequestEvaluators, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestEvaluatorsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestEvaluators, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestAgentsExecuteOn>;
/** @internal */
export declare const RetrieveAgentRequestGuardrails$inboundSchema: z.ZodType<RetrieveAgentRequestGuardrails, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestGuardrailsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestGuardrails, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestSettings$inboundSchema: z.ZodType<RetrieveAgentRequestSettings, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestSettingsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestSettings, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatJsonSchema$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatJsonSchema, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatJsonSchemaFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatJsonSchema, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatAgentsJSONSchema$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatAgentsJSONSchema, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatAgentsJSONSchemaFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatAgentsJSONSchema, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatJSONObject$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatJSONObject, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatJSONObjectFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatJSONObject, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatText$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatText, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatTextFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatText, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormat$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormat, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormat, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestReasoningEffort$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestReasoningEffort>;
/** @internal */
export declare const RetrieveAgentRequestStop$inboundSchema: z.ZodType<RetrieveAgentRequestStop, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestStopFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestStop, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestThinking$inboundSchema: z.ZodType<RetrieveAgentRequestThinking, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestThinkingFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestThinking, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestToolChoiceType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestToolChoiceType>;
/** @internal */
export declare const RetrieveAgentRequestToolChoiceFunction$inboundSchema: z.ZodType<RetrieveAgentRequestToolChoiceFunction, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestToolChoiceFunctionFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestToolChoiceFunction, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestToolChoice2$inboundSchema: z.ZodType<RetrieveAgentRequestToolChoice2, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestToolChoice2FromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestToolChoice2, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestToolChoice1$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestToolChoice1>;
/** @internal */
export declare const RetrieveAgentRequestToolChoice$inboundSchema: z.ZodType<RetrieveAgentRequestToolChoice, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestToolChoiceFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestToolChoice, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestModalities$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestModalities>;
/** @internal */
export declare const RetrieveAgentRequestId1$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestId1>;
/** @internal */
export declare const RetrieveAgentRequestId$inboundSchema: z.ZodType<RetrieveAgentRequestId, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestIdFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestId, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestAgentsResponseExecuteOn$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestAgentsResponseExecuteOn>;
/** @internal */
export declare const RetrieveAgentRequestAgentsGuardrails$inboundSchema: z.ZodType<RetrieveAgentRequestAgentsGuardrails, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestAgentsGuardrailsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestAgentsGuardrails, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbacks$inboundSchema: z.ZodType<RetrieveAgentRequestFallbacks, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbacksFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbacks, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestAgentsType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestAgentsType>;
/** @internal */
export declare const RetrieveAgentRequestCache$inboundSchema: z.ZodType<RetrieveAgentRequestCache, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestCacheFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestCache, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancerType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestLoadBalancerType>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancerModels$inboundSchema: z.ZodType<RetrieveAgentRequestLoadBalancerModels, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestLoadBalancerModelsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestLoadBalancerModels, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancer1$inboundSchema: z.ZodType<RetrieveAgentRequestLoadBalancer1, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestLoadBalancer1FromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestLoadBalancer1, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancer$inboundSchema: z.ZodType<RetrieveAgentRequestLoadBalancer, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestLoadBalancerFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestLoadBalancer, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestTimeout$inboundSchema: z.ZodType<RetrieveAgentRequestTimeout, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestTimeoutFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestTimeout, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestParameters$inboundSchema: z.ZodType<RetrieveAgentRequestParameters, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestParametersFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestParameters, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestRetry$inboundSchema: z.ZodType<RetrieveAgentRequestRetry, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestRetryFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestRetry, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatAgentsResponseJsonSchema$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatAgentsResponseJsonSchema, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatAgentsResponseJsonSchemaFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatAgentsResponseJsonSchema, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatAgentsResponse200JSONSchema$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatAgentsResponse200JSONSchema, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatAgentsResponse200JSONSchemaFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatAgentsResponse200JSONSchema, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatAgentsJSONObject$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatAgentsJSONObject, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatAgentsJSONObjectFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatAgentsJSONObject, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseFormatAgentsText$inboundSchema: z.ZodType<RetrieveAgentRequestResponseFormatAgentsText, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseFormatAgentsTextFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseFormatAgentsText, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationResponseFormat$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationResponseFormat, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationResponseFormatFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationResponseFormat, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationReasoningEffort$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestFallbackModelConfigurationReasoningEffort>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationStop$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationStop, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationStopFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationStop, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationThinking$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationThinking, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationThinkingFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationThinking, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestToolChoiceAgentsType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestToolChoiceAgentsType>;
/** @internal */
export declare const RetrieveAgentRequestToolChoiceAgentsFunction$inboundSchema: z.ZodType<RetrieveAgentRequestToolChoiceAgentsFunction, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestToolChoiceAgentsFunctionFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestToolChoiceAgentsFunction, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestToolChoiceAgents2$inboundSchema: z.ZodType<RetrieveAgentRequestToolChoiceAgents2, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestToolChoiceAgents2FromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestToolChoiceAgents2, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestToolChoiceAgents1$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestToolChoiceAgents1>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationToolChoice$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationToolChoice, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationToolChoiceFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationToolChoice, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationModalities$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestFallbackModelConfigurationModalities>;
/** @internal */
export declare const RetrieveAgentRequestIdAgents1$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestIdAgents1>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationId$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationId, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationIdFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationId, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationExecuteOn$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestFallbackModelConfigurationExecuteOn>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationGuardrails$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationGuardrails, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationGuardrailsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationGuardrails, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationFallbacks$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationFallbacks, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationFallbacksFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationFallbacks, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestFallbackModelConfigurationType>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationCache$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationCache, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationCacheFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationCache, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancerAgentsType$inboundSchema: z.ZodNativeEnum<typeof RetrieveAgentRequestLoadBalancerAgentsType>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancerAgentsModels$inboundSchema: z.ZodType<RetrieveAgentRequestLoadBalancerAgentsModels, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestLoadBalancerAgentsModelsFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestLoadBalancerAgentsModels, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestLoadBalancerAgents1$inboundSchema: z.ZodType<RetrieveAgentRequestLoadBalancerAgents1, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestLoadBalancerAgents1FromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestLoadBalancerAgents1, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationLoadBalancer$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationLoadBalancer, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationLoadBalancerFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationLoadBalancer, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationTimeout$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationTimeout, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationTimeoutFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationTimeout, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationParameters$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationParameters, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationParametersFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationParameters, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfigurationRetry$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfigurationRetry, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationRetryFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfigurationRetry, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfiguration2$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfiguration2, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfiguration2FromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfiguration2, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestFallbackModelConfiguration$inboundSchema: z.ZodType<RetrieveAgentRequestFallbackModelConfiguration, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestFallbackModelConfigurationFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestFallbackModelConfiguration, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestModel$inboundSchema: z.ZodType<RetrieveAgentRequestModel, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestModelFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestModel, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestHeaders$inboundSchema: z.ZodType<RetrieveAgentRequestHeaders, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestHeadersFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestHeaders, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestA2AAgentConfiguration$inboundSchema: z.ZodType<RetrieveAgentRequestA2AAgentConfiguration, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestA2AAgentConfigurationFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestA2AAgentConfiguration, SDKValidationError>;
/** @internal */
export declare const RetrieveAgentRequestResponseBody$inboundSchema: z.ZodType<RetrieveAgentRequestResponseBody, z.ZodTypeDef, unknown>;
export declare function retrieveAgentRequestResponseBodyFromJSON(jsonString: string): SafeParseResult<RetrieveAgentRequestResponseBody, SDKValidationError>;
//# sourceMappingURL=retrieveagentrequest.d.ts.map