@orq-ai/node 4.5.0-rc.4 → 4.5.0-rc.40

package/models/operations/listagents.d.ts

@@ -3,6 +3,17 @@ 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";
+/**
+ * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+ */
+export declare const QueryParamType: {
+    readonly Internal: "internal";
+    readonly A2a: "a2a";
+};
+/**
+ * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+ */
+export type QueryParamType = ClosedEnum<typeof QueryParamType>;
 export type ListAgentsRequest = {
     /**
      * A limit on the number of objects to be returned. Limit can range between 1 and 200. When not provided, returns all agents without pagination.
@@ -16,6 +27,10 @@ export type ListAgentsRequest = {
      * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list.
      */
     endingBefore?: string | undefined;
+    /**
+     * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+     */
+    type?: QueryParamType | undefined;
 };
 export declare const ListAgentsObject: {
     readonly List: "list";
@@ -24,7 +39,7 @@ export type ListAgentsObject = ClosedEnum<typeof ListAgentsObject>;
 /**
  * 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 ListAgentsStatus: {
+export declare const ListAgentsDataStatus: {
     readonly Live: "live";
     readonly Draft: "draft";
     readonly Pending: "pending";
@@ -33,11 +48,172 @@ export declare const ListAgentsStatus: {
 /**
  * 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 ListAgentsStatus = ClosedEnum<typeof ListAgentsStatus>;
+export type ListAgentsDataStatus = ClosedEnum<typeof ListAgentsDataStatus>;
+export type ListAgentsDataTeamOfAgents = {
+    /**
+     * 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 ListAgentsDataMetrics = {
+    totalCost: number;
+};
+export type ListAgentsDataKnowledgeBases = {
+    /**
+     * Unique identifier of the knowledge base to search
+     */
+    knowledgeId: string;
+};
+export declare const ListAgentsDataSource: {
+    readonly Internal: "internal";
+    readonly External: "external";
+    readonly Experiment: "experiment";
+};
+export type ListAgentsDataSource = ClosedEnum<typeof ListAgentsDataSource>;
+export type DataHeaders = {
+    /**
+     * 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. External agents manage their own model/settings.
+ */
+export type DataA2AAgentConfiguration = {
+    /**
+     * 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]: DataHeaders;
+    } | undefined;
+    /**
+     * Cached agent card from discovery. Refreshed periodically.
+     */
+    cachedCard?: any | undefined;
+};
+export type Data2 = {
+    id: string;
+    /**
+     * Unique identifier for the agent within the workspace
+     */
+    key: string;
+    displayName?: string | undefined;
+    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: ListAgentsDataStatus;
+    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<ListAgentsDataTeamOfAgents> | undefined;
+    metrics?: ListAgentsDataMetrics | undefined;
+    /**
+     * Extracted variables from agent instructions
+     */
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * Agent knowledge bases reference
+     */
+    knowledgeBases?: Array<ListAgentsDataKnowledgeBases> | undefined;
+    source?: ListAgentsDataSource | undefined;
+    /**
+     * External A2A-compliant agent
+     */
+    type: "a2a";
+    /**
+     * Role fetched from agent card name or user-provided
+     */
+    role: string;
+    /**
+     * Description fetched from agent card or user-provided
+     */
+    description: string;
+    systemPrompt?: string | undefined;
+    /**
+     * Instructions from agent card description or user-provided
+     */
+    instructions: string;
+    /**
+     * A2A configuration with agent endpoint and authentication. External agents manage their own model/settings.
+     */
+    a2a: DataA2AAgentConfiguration;
+};
+/**
+ * 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 DataStatus: {
+    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 DataStatus = ClosedEnum<typeof DataStatus>;
+export type DataTeamOfAgents = {
+    /**
+     * 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 DataMetrics = {
+    totalCost: number;
+};
+export type DataKnowledgeBases = {
+    /**
+     * Unique identifier of the knowledge base to search
+     */
+    knowledgeId: string;
+};
+export declare const DataSource: {
+    readonly Internal: "internal";
+    readonly External: "external";
+    readonly Experiment: "experiment";
+};
+export type DataSource = ClosedEnum<typeof DataSource>;
 /**
  * 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 ListAgentsToolApprovalRequired: {
+export declare const DataToolApprovalRequired: {
     readonly All: "all";
     readonly RespectTool: "respect_tool";
     readonly None: "none";
@@ -45,8 +221,8 @@ export declare const ListAgentsToolApprovalRequired: {
 /**
  * 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 ListAgentsToolApprovalRequired = ClosedEnum<typeof ListAgentsToolApprovalRequired>;
-export type ListAgentsConditions = {
+export type DataToolApprovalRequired = ClosedEnum<typeof DataToolApprovalRequired>;
+export type DataConditions = {
     /**
      * The argument of the tool call to evaluate
      */
@@ -60,7 +236,7 @@ export type ListAgentsConditions = {
      */
     value: string;
 };
-export type ListAgentsTools = {
+export type DataTools = {
     /**
      * The id of the resource
      */
@@ -80,7 +256,7 @@ export type ListAgentsTools = {
      * Nested tool ID for MCP tools (identifies specific tool within MCP server)
      */
     toolId?: string | undefined;
-    conditions?: Array<ListAgentsConditions> | undefined;
+    conditions?: Array<DataConditions> | undefined;
     /**
      * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
      */
@@ -89,15 +265,15 @@ export type ListAgentsTools = {
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export declare const ListAgentsExecuteOn: {
+export declare const DataExecuteOn: {
     readonly Input: "input";
     readonly Output: "output";
 };
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type ListAgentsExecuteOn = ClosedEnum<typeof ListAgentsExecuteOn>;
-export type ListAgentsEvaluators = {
+export type DataExecuteOn = ClosedEnum<typeof DataExecuteOn>;
+export type DataEvaluators = {
     /**
      * Unique key or identifier of the evaluator
      */
@@ -109,20 +285,20 @@ export type ListAgentsEvaluators = {
     /**
      * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
      */
-    executeOn: ListAgentsExecuteOn;
+    executeOn: DataExecuteOn;
 };
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export declare const ListAgentsAgentsExecuteOn: {
+export declare const ListAgentsDataExecuteOn: {
     readonly Input: "input";
     readonly Output: "output";
 };
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type ListAgentsAgentsExecuteOn = ClosedEnum<typeof ListAgentsAgentsExecuteOn>;
-export type ListAgentsGuardrails = {
+export type ListAgentsDataExecuteOn = ClosedEnum<typeof ListAgentsDataExecuteOn>;
+export type DataGuardrails = {
     /**
      * Unique key or identifier of the evaluator
      */
@@ -134,9 +310,9 @@ export type ListAgentsGuardrails = {
     /**
      * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
      */
-    executeOn: ListAgentsAgentsExecuteOn;
+    executeOn: ListAgentsDataExecuteOn;
 };
-export type ListAgentsSettings = {
+export type DataSettings = {
     /**
      * Maximum iterations(llm calls) before the agent will stop executing.
      */
@@ -152,58 +328,16 @@ export type ListAgentsSettings = {
     /**
      * 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: ListAgentsToolApprovalRequired;
-    tools?: Array<ListAgentsTools> | undefined;
+    toolApprovalRequired: DataToolApprovalRequired;
+    tools?: Array<DataTools> | undefined;
     /**
      * Configuration for an evaluator applied to the agent
      */
-    evaluators?: Array<ListAgentsEvaluators> | undefined;
+    evaluators?: Array<DataEvaluators> | undefined;
     /**
      * Configuration for a guardrail applied to the agent
      */
-    guardrails?: Array<ListAgentsGuardrails> | undefined;
-};
-/**
- * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
- */
-export declare const ListAgentsVoice: {
-    readonly Alloy: "alloy";
-    readonly Echo: "echo";
-    readonly Fable: "fable";
-    readonly Onyx: "onyx";
-    readonly Nova: "nova";
-    readonly Shimmer: "shimmer";
-};
-/**
- * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
- */
-export type ListAgentsVoice = ClosedEnum<typeof ListAgentsVoice>;
-/**
- * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
- */
-export declare const ListAgentsFormat: {
-    readonly Wav: "wav";
-    readonly Mp3: "mp3";
-    readonly Flac: "flac";
-    readonly Opus: "opus";
-    readonly Pcm16: "pcm16";
-};
-/**
- * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
- */
-export type ListAgentsFormat = ClosedEnum<typeof ListAgentsFormat>;
-/**
- * Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
- */
-export type ListAgentsAudio = {
-    /**
-     * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
-     */
-    voice: ListAgentsVoice;
-    /**
-     * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
-     */
-    format: ListAgentsFormat;
+    guardrails?: Array<DataGuardrails> | undefined;
 };
 export type ListAgentsResponseFormatJsonSchema = {
     /**
@@ -251,7 +385,7 @@ export type ListAgentsResponseFormatText = {
 /**
  * An object specifying the format that the model must output
  */
-export type ListAgentsResponseFormat = ListAgentsResponseFormatText | ListAgentsResponseFormatJSONObject | ListAgentsResponseFormatAgentsJSONSchema;
+export type DataResponseFormat = ListAgentsResponseFormatText | ListAgentsResponseFormatJSONObject | ListAgentsResponseFormatAgentsJSONSchema;
 /**
  * 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.
  *
@@ -264,7 +398,7 @@ export type ListAgentsResponseFormat = ListAgentsResponseFormatText | ListAgents
  *
  * Any of "none", "minimal", "low", "medium", "high", "xhigh".
  */
-export declare const ListAgentsReasoningEffort: {
+export declare const DataReasoningEffort: {
     readonly None: "none";
     readonly Minimal: "minimal";
     readonly Low: "low";
@@ -284,21 +418,12 @@ export declare const ListAgentsReasoningEffort: {
  *
  * Any of "none", "minimal", "low", "medium", "high", "xhigh".
  */
-export type ListAgentsReasoningEffort = ClosedEnum<typeof ListAgentsReasoningEffort>;
+export type DataReasoningEffort = ClosedEnum<typeof DataReasoningEffort>;
 /**
  * Up to 4 sequences where the API will stop generating further tokens.
  */
-export type ListAgentsStop = string | Array<string>;
-/**
- * Options for streaming response. Only set this when you set stream: true.
- */
-export type ListAgentsStreamOptions = {
-    /**
-     * If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value.
-     */
-    includeUsage?: boolean | undefined;
-};
-export type ListAgentsThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema;
+export type DataStop = string | Array<string>;
+export type DataThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema;
 /**
  * The type of the tool. Currently, only function is supported.
  */
@@ -331,12 +456,12 @@ export type ListAgentsToolChoice1 = ClosedEnum<typeof ListAgentsToolChoice1>;
 /**
  * Controls which (if any) tool is called by the model.
  */
-export type ListAgentsToolChoice = ListAgentsToolChoice2 | ListAgentsToolChoice1;
-export declare const ListAgentsModalities: {
+export type DataToolChoice = ListAgentsToolChoice2 | ListAgentsToolChoice1;
+export declare const DataModalities: {
     readonly Text: "text";
     readonly Audio: "audio";
 };
-export type ListAgentsModalities = ClosedEnum<typeof ListAgentsModalities>;
+export type DataModalities = ClosedEnum<typeof DataModalities>;
 /**
  * The key of the guardrail.
  */
@@ -349,57 +474,44 @@ export declare const ListAgentsId1: {
  * The key of the guardrail.
  */
 export type ListAgentsId1 = ClosedEnum<typeof ListAgentsId1>;
-export type ListAgentsId = ListAgentsId1 | string;
+export type DataId = ListAgentsId1 | string;
 /**
  * Determines whether the guardrail runs on the input (user message) or output (model response).
  */
-export declare const ListAgentsAgentsResponseExecuteOn: {
+export declare const ListAgentsDataAgentsExecuteOn: {
     readonly Input: "input";
     readonly Output: "output";
 };
 /**
  * Determines whether the guardrail runs on the input (user message) or output (model response).
  */
-export type ListAgentsAgentsResponseExecuteOn = ClosedEnum<typeof ListAgentsAgentsResponseExecuteOn>;
-export type ListAgentsAgentsGuardrails = {
+export type ListAgentsDataAgentsExecuteOn = ClosedEnum<typeof ListAgentsDataAgentsExecuteOn>;
+export type ListAgentsDataGuardrails = {
     id: ListAgentsId1 | string;
     /**
      * Determines whether the guardrail runs on the input (user message) or output (model response).
      */
-    executeOn: ListAgentsAgentsResponseExecuteOn;
+    executeOn: ListAgentsDataAgentsExecuteOn;
 };
-export type ListAgentsFallbacks = {
+export type DataFallbacks = {
     /**
      * Fallback model identifier
      */
     model: string;
 };
-/**
- * Retry configuration for the request
- */
-export type ListAgentsAgentsRetry = {
-    /**
-     * Number of retry attempts (1-5)
-     */
-    count: number;
-    /**
-     * HTTP status codes that trigger retry logic
-     */
-    onCodes?: Array<number> | undefined;
-};
-export declare const ListAgentsType: {
+export declare const ListAgentsDataAgentsResponseType: {
     readonly ExactMatch: "exact_match";
 };
-export type ListAgentsType = ClosedEnum<typeof ListAgentsType>;
+export type ListAgentsDataAgentsResponseType = ClosedEnum<typeof ListAgentsDataAgentsResponseType>;
 /**
  * Cache configuration for the request.
  */
-export type ListAgentsCache = {
+export type DataCache = {
     /**
      * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
      */
     ttl: number;
-    type: ListAgentsType;
+    type: ListAgentsDataAgentsResponseType;
 };
 export declare const ListAgentsLoadBalancerType: {
     readonly WeightBased: "weight_based";
@@ -422,11 +534,11 @@ export type ListAgentsLoadBalancer1 = {
 /**
  * Load balancer configuration for the request.
  */
-export type ListAgentsLoadBalancer = ListAgentsLoadBalancer1;
+export type DataLoadBalancer = ListAgentsLoadBalancer1;
 /**
  * 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 ListAgentsTimeout = {
+export type DataTimeout = {
     /**
      * Timeout value in milliseconds
      */
@@ -435,15 +547,11 @@ export type ListAgentsTimeout = {
 /**
  * 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 ListAgentsParameters = {
+export type DataParameters = {
     /**
      * The name to display on the trace. If not specified, the default system name will be used.
      */
     name?: string | undefined;
-    /**
-     * Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
-     */
-    audio?: ListAgentsAudio | null | 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.
      */
@@ -460,18 +568,6 @@ export type ListAgentsParameters = {
      * 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;
-    /**
-     * Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message.
-     */
-    logprobs?: boolean | null | undefined;
-    /**
-     * An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.
-     */
-    topLogprobs?: number | null | undefined;
-    /**
-     * How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs.
-     */
-    n?: 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.
      */
@@ -492,7 +588,7 @@ export type ListAgentsParameters = {
      *
      * Any of "none", "minimal", "low", "medium", "high", "xhigh".
      */
-    reasoningEffort?: ListAgentsReasoningEffort | undefined;
+    reasoningEffort?: DataReasoningEffort | undefined;
     /**
      * Adjusts response verbosity. Lower levels yield shorter answers.
      */
@@ -505,10 +601,6 @@ export type ListAgentsParameters = {
      * Up to 4 sequences where the API will stop generating further tokens.
      */
     stop?: string | Array<string> | null | undefined;
-    /**
-     * Options for streaming response. Only set this when you set stream: true.
-     */
-    streamOptions?: ListAgentsStreamOptions | null | undefined;
     thinking?: components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | 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.
@@ -533,23 +625,19 @@ export type ListAgentsParameters = {
     /**
      * 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<ListAgentsModalities> | null | undefined;
+    modalities?: Array<DataModalities> | null | undefined;
     /**
      * A list of guardrails to apply to the request.
      */
-    guardrails?: Array<ListAgentsAgentsGuardrails> | undefined;
+    guardrails?: Array<ListAgentsDataGuardrails> | undefined;
     /**
      * Array of fallback models to use if primary model fails
      */
-    fallbacks?: Array<ListAgentsFallbacks> | undefined;
-    /**
-     * Retry configuration for the request
-     */
-    retry?: ListAgentsAgentsRetry | undefined;
+    fallbacks?: Array<DataFallbacks> | undefined;
     /**
      * Cache configuration for the request.
      */
-    cache?: ListAgentsCache | undefined;
+    cache?: DataCache | undefined;
     /**
      * Load balancer configuration for the request.
      */
@@ -557,12 +645,12 @@ export type ListAgentsParameters = {
     /**
      * 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?: ListAgentsTimeout | undefined;
+    timeout?: DataTimeout | 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 ListAgentsRetry = {
+export type DataRetry = {
     /**
      * Number of retry attempts (1-5)
      */
@@ -572,48 +660,6 @@ export type ListAgentsRetry = {
      */
     onCodes?: Array<number> | undefined;
 };
-/**
- * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
- */
-export declare const ListAgentsFallbackModelConfigurationVoice: {
-    readonly Alloy: "alloy";
-    readonly Echo: "echo";
-    readonly Fable: "fable";
-    readonly Onyx: "onyx";
-    readonly Nova: "nova";
-    readonly Shimmer: "shimmer";
-};
-/**
- * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
- */
-export type ListAgentsFallbackModelConfigurationVoice = ClosedEnum<typeof ListAgentsFallbackModelConfigurationVoice>;
-/**
- * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
- */
-export declare const ListAgentsFallbackModelConfigurationFormat: {
-    readonly Wav: "wav";
-    readonly Mp3: "mp3";
-    readonly Flac: "flac";
-    readonly Opus: "opus";
-    readonly Pcm16: "pcm16";
-};
-/**
- * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
- */
-export type ListAgentsFallbackModelConfigurationFormat = ClosedEnum<typeof ListAgentsFallbackModelConfigurationFormat>;
-/**
- * Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
- */
-export type ListAgentsFallbackModelConfigurationAudio = {
-    /**
-     * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
-     */
-    voice: ListAgentsFallbackModelConfigurationVoice;
-    /**
-     * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
-     */
-    format: ListAgentsFallbackModelConfigurationFormat;
-};
 export type ListAgentsResponseFormatAgentsResponseJsonSchema = {
     /**
      * A description of what the response format is for, used by the model to determine how to respond in the format.
@@ -698,15 +744,6 @@ export type ListAgentsFallbackModelConfigurationReasoningEffort = ClosedEnum<typ
  * Up to 4 sequences where the API will stop generating further tokens.
  */
 export type ListAgentsFallbackModelConfigurationStop = string | Array<string>;
-/**
- * Options for streaming response. Only set this when you set stream: true.
- */
-export type ListAgentsFallbackModelConfigurationStreamOptions = {
-    /**
-     * If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value.
-     */
-    includeUsage?: boolean | undefined;
-};
 export type ListAgentsFallbackModelConfigurationThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema;
 /**
  * The type of the tool. Currently, only function is supported.
@@ -783,19 +820,6 @@ export type ListAgentsFallbackModelConfigurationFallbacks = {
      */
     model: string;
 };
-/**
- * Retry configuration for the request
- */
-export type ListAgentsFallbackModelConfigurationAgentsRetry = {
-    /**
-     * Number of retry attempts (1-5)
-     */
-    count: number;
-    /**
-     * HTTP status codes that trigger retry logic
-     */
-    onCodes?: Array<number> | undefined;
-};
 export declare const ListAgentsFallbackModelConfigurationType: {
     readonly ExactMatch: "exact_match";
 };
@@ -849,10 +873,6 @@ export type ListAgentsFallbackModelConfigurationParameters = {
      * The name to display on the trace. If not specified, the default system name will be used.
      */
     name?: string | undefined;
-    /**
-     * Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
-     */
-    audio?: ListAgentsFallbackModelConfigurationAudio | null | 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.
      */
@@ -869,18 +889,6 @@ export type ListAgentsFallbackModelConfigurationParameters = {
      * 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;
-    /**
-     * Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message.
-     */
-    logprobs?: boolean | null | undefined;
-    /**
-     * An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.
-     */
-    topLogprobs?: number | null | undefined;
-    /**
-     * How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs.
-     */
-    n?: 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.
      */
@@ -914,10 +922,6 @@ export type ListAgentsFallbackModelConfigurationParameters = {
      * Up to 4 sequences where the API will stop generating further tokens.
      */
     stop?: string | Array<string> | null | undefined;
-    /**
-     * Options for streaming response. Only set this when you set stream: true.
-     */
-    streamOptions?: ListAgentsFallbackModelConfigurationStreamOptions | null | undefined;
     thinking?: components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | 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.
@@ -951,10 +955,6 @@ export type ListAgentsFallbackModelConfigurationParameters = {
      * Array of fallback models to use if primary model fails
      */
     fallbacks?: Array<ListAgentsFallbackModelConfigurationFallbacks> | undefined;
-    /**
-     * Retry configuration for the request
-     */
-    retry?: ListAgentsFallbackModelConfigurationAgentsRetry | undefined;
     /**
      * Cache configuration for the request.
      */
@@ -1001,8 +1001,8 @@ export type ListAgentsFallbackModelConfiguration2 = {
 /**
  * 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 ListAgentsFallbackModelConfiguration = ListAgentsFallbackModelConfiguration2 | string;
-export type ListAgentsModel = {
+export type DataFallbackModelConfiguration = ListAgentsFallbackModelConfiguration2 | string;
+export type DataModel = {
     /**
      * The database ID of the primary model
      */
@@ -1014,42 +1014,17 @@ export type ListAgentsModel = {
     /**
      * 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?: ListAgentsParameters | undefined;
+    parameters?: DataParameters | 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?: ListAgentsRetry | undefined;
+    retry?: DataRetry | 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<ListAgentsFallbackModelConfiguration2 | string> | null | undefined;
 };
-export type ListAgentsTeamOfAgents = {
-    /**
-     * 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 ListAgentsMetrics = {
-    totalCost: number;
-};
-export type ListAgentsKnowledgeBases = {
-    /**
-     * Unique identifier of the knowledge base to search
-     */
-    knowledgeId: string;
-};
-export declare const ListAgentsSource: {
-    readonly Internal: "internal";
-    readonly External: "external";
-    readonly Experiment: "experiment";
-};
-export type ListAgentsSource = ClosedEnum<typeof ListAgentsSource>;
-export type ListAgentsData = {
+export type Data1 = {
     id: string;
     /**
      * Unique identifier for the agent within the workspace
@@ -1060,16 +1035,10 @@ export type ListAgentsData = {
     updatedById?: string | null | undefined;
     created?: string | undefined;
     updated?: string | undefined;
-    role: string;
-    description: string;
-    systemPrompt?: string | undefined;
-    instructions: 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.
      */
-    status: ListAgentsStatus;
-    settings?: ListAgentsSettings | undefined;
-    model: ListAgentsModel;
+    status: DataStatus;
     versionHash?: string | undefined;
     /**
      * Entity storage path in the format: `project/folder/subfolder/...`
@@ -1084,12 +1053,12 @@ export type ListAgentsData = {
     /**
      * Array of memory store identifiers. Accepts both memory store IDs and keys.
      */
-    memoryStores: Array<string>;
+    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<ListAgentsTeamOfAgents>;
-    metrics?: ListAgentsMetrics | undefined;
+    teamOfAgents?: Array<DataTeamOfAgents> | undefined;
+    metrics?: DataMetrics | undefined;
     /**
      * Extracted variables from agent instructions
      */
@@ -1099,22 +1068,36 @@ export type ListAgentsData = {
     /**
      * Agent knowledge bases reference
      */
-    knowledgeBases?: Array<ListAgentsKnowledgeBases> | undefined;
-    source?: ListAgentsSource | undefined;
+    knowledgeBases?: Array<DataKnowledgeBases> | undefined;
+    source?: DataSource | undefined;
+    /**
+     * Orquesta-managed agent
+     */
+    type: "internal";
+    role: string;
+    description: string;
+    systemPrompt?: string | undefined;
+    instructions: string;
+    settings?: DataSettings | undefined;
+    model: DataModel;
 };
+export type ListAgentsData = Data1 | Data2;
 /**
  * Successfully retrieved the list of agents. Returns a paginated response containing agent manifests with complete configurations, including primary and fallback models, tools, knowledge bases, and execution settings.
  */
 export type ListAgentsResponseBody = {
     object: ListAgentsObject;
-    data: Array<ListAgentsData>;
+    data: Array<Data1 | Data2>;
     hasMore: boolean;
 };
 /** @internal */
+export declare const QueryParamType$outboundSchema: z.ZodNativeEnum<typeof QueryParamType>;
+/** @internal */
 export type ListAgentsRequest$Outbound = {
     limit?: number | undefined;
     starting_after?: string | undefined;
     ending_before?: string | undefined;
+    type?: string | undefined;
 };
 /** @internal */
 export declare const ListAgentsRequest$outboundSchema: z.ZodType<ListAgentsRequest$Outbound, z.ZodTypeDef, ListAgentsRequest>;
@@ -1122,35 +1105,61 @@ export declare function listAgentsRequestToJSON(listAgentsRequest: ListAgentsReq
 /** @internal */
 export declare const ListAgentsObject$inboundSchema: z.ZodNativeEnum<typeof ListAgentsObject>;
 /** @internal */
-export declare const ListAgentsStatus$inboundSchema: z.ZodNativeEnum<typeof ListAgentsStatus>;
+export declare const ListAgentsDataStatus$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataStatus>;
+/** @internal */
+export declare const ListAgentsDataTeamOfAgents$inboundSchema: z.ZodType<ListAgentsDataTeamOfAgents, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<ListAgentsDataTeamOfAgents, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataMetrics$inboundSchema: z.ZodType<ListAgentsDataMetrics, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataMetricsFromJSON(jsonString: string): SafeParseResult<ListAgentsDataMetrics, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataKnowledgeBases$inboundSchema: z.ZodType<ListAgentsDataKnowledgeBases, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<ListAgentsDataKnowledgeBases, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof ListAgentsToolApprovalRequired>;
+export declare const ListAgentsDataSource$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataSource>;
 /** @internal */
-export declare const ListAgentsConditions$inboundSchema: z.ZodType<ListAgentsConditions, z.ZodTypeDef, unknown>;
-export declare function listAgentsConditionsFromJSON(jsonString: string): SafeParseResult<ListAgentsConditions, SDKValidationError>;
+export declare const DataHeaders$inboundSchema: z.ZodType<DataHeaders, z.ZodTypeDef, unknown>;
+export declare function dataHeadersFromJSON(jsonString: string): SafeParseResult<DataHeaders, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsTools$inboundSchema: z.ZodType<ListAgentsTools, z.ZodTypeDef, unknown>;
-export declare function listAgentsToolsFromJSON(jsonString: string): SafeParseResult<ListAgentsTools, SDKValidationError>;
+export declare const DataA2AAgentConfiguration$inboundSchema: z.ZodType<DataA2AAgentConfiguration, z.ZodTypeDef, unknown>;
+export declare function dataA2AAgentConfigurationFromJSON(jsonString: string): SafeParseResult<DataA2AAgentConfiguration, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsExecuteOn>;
+export declare const Data2$inboundSchema: z.ZodType<Data2, z.ZodTypeDef, unknown>;
+export declare function data2FromJSON(jsonString: string): SafeParseResult<Data2, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsEvaluators$inboundSchema: z.ZodType<ListAgentsEvaluators, z.ZodTypeDef, unknown>;
-export declare function listAgentsEvaluatorsFromJSON(jsonString: string): SafeParseResult<ListAgentsEvaluators, SDKValidationError>;
+export declare const DataStatus$inboundSchema: z.ZodNativeEnum<typeof DataStatus>;
 /** @internal */
-export declare const ListAgentsAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsAgentsExecuteOn>;
+export declare const DataTeamOfAgents$inboundSchema: z.ZodType<DataTeamOfAgents, z.ZodTypeDef, unknown>;
+export declare function dataTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<DataTeamOfAgents, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsGuardrails$inboundSchema: z.ZodType<ListAgentsGuardrails, z.ZodTypeDef, unknown>;
-export declare function listAgentsGuardrailsFromJSON(jsonString: string): SafeParseResult<ListAgentsGuardrails, SDKValidationError>;
+export declare const DataMetrics$inboundSchema: z.ZodType<DataMetrics, z.ZodTypeDef, unknown>;
+export declare function dataMetricsFromJSON(jsonString: string): SafeParseResult<DataMetrics, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsSettings$inboundSchema: z.ZodType<ListAgentsSettings, z.ZodTypeDef, unknown>;
-export declare function listAgentsSettingsFromJSON(jsonString: string): SafeParseResult<ListAgentsSettings, SDKValidationError>;
+export declare const DataKnowledgeBases$inboundSchema: z.ZodType<DataKnowledgeBases, z.ZodTypeDef, unknown>;
+export declare function dataKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<DataKnowledgeBases, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsVoice$inboundSchema: z.ZodNativeEnum<typeof ListAgentsVoice>;
+export declare const DataSource$inboundSchema: z.ZodNativeEnum<typeof DataSource>;
 /** @internal */
-export declare const ListAgentsFormat$inboundSchema: z.ZodNativeEnum<typeof ListAgentsFormat>;
+export declare const DataToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof DataToolApprovalRequired>;
 /** @internal */
-export declare const ListAgentsAudio$inboundSchema: z.ZodType<ListAgentsAudio, z.ZodTypeDef, unknown>;
-export declare function listAgentsAudioFromJSON(jsonString: string): SafeParseResult<ListAgentsAudio, SDKValidationError>;
+export declare const DataConditions$inboundSchema: z.ZodType<DataConditions, z.ZodTypeDef, unknown>;
+export declare function dataConditionsFromJSON(jsonString: string): SafeParseResult<DataConditions, SDKValidationError>;
+/** @internal */
+export declare const DataTools$inboundSchema: z.ZodType<DataTools, z.ZodTypeDef, unknown>;
+export declare function dataToolsFromJSON(jsonString: string): SafeParseResult<DataTools, SDKValidationError>;
+/** @internal */
+export declare const DataExecuteOn$inboundSchema: z.ZodNativeEnum<typeof DataExecuteOn>;
+/** @internal */
+export declare const DataEvaluators$inboundSchema: z.ZodType<DataEvaluators, z.ZodTypeDef, unknown>;
+export declare function dataEvaluatorsFromJSON(jsonString: string): SafeParseResult<DataEvaluators, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataExecuteOn>;
+/** @internal */
+export declare const DataGuardrails$inboundSchema: z.ZodType<DataGuardrails, z.ZodTypeDef, unknown>;
+export declare function dataGuardrailsFromJSON(jsonString: string): SafeParseResult<DataGuardrails, SDKValidationError>;
+/** @internal */
+export declare const DataSettings$inboundSchema: z.ZodType<DataSettings, z.ZodTypeDef, unknown>;
+export declare function dataSettingsFromJSON(jsonString: string): SafeParseResult<DataSettings, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsResponseFormatJsonSchema$inboundSchema: z.ZodType<ListAgentsResponseFormatJsonSchema, z.ZodTypeDef, unknown>;
 export declare function listAgentsResponseFormatJsonSchemaFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormatJsonSchema, SDKValidationError>;
@@ -1164,19 +1173,16 @@ export declare function listAgentsResponseFormatJSONObjectFromJSON(jsonString: s
 export declare const ListAgentsResponseFormatText$inboundSchema: z.ZodType<ListAgentsResponseFormatText, z.ZodTypeDef, unknown>;
 export declare function listAgentsResponseFormatTextFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormatText, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsResponseFormat$inboundSchema: z.ZodType<ListAgentsResponseFormat, z.ZodTypeDef, unknown>;
-export declare function listAgentsResponseFormatFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormat, SDKValidationError>;
+export declare const DataResponseFormat$inboundSchema: z.ZodType<DataResponseFormat, z.ZodTypeDef, unknown>;
+export declare function dataResponseFormatFromJSON(jsonString: string): SafeParseResult<DataResponseFormat, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsReasoningEffort$inboundSchema: z.ZodNativeEnum<typeof ListAgentsReasoningEffort>;
+export declare const DataReasoningEffort$inboundSchema: z.ZodNativeEnum<typeof DataReasoningEffort>;
 /** @internal */
-export declare const ListAgentsStop$inboundSchema: z.ZodType<ListAgentsStop, z.ZodTypeDef, unknown>;
-export declare function listAgentsStopFromJSON(jsonString: string): SafeParseResult<ListAgentsStop, SDKValidationError>;
+export declare const DataStop$inboundSchema: z.ZodType<DataStop, z.ZodTypeDef, unknown>;
+export declare function dataStopFromJSON(jsonString: string): SafeParseResult<DataStop, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsStreamOptions$inboundSchema: z.ZodType<ListAgentsStreamOptions, z.ZodTypeDef, unknown>;
-export declare function listAgentsStreamOptionsFromJSON(jsonString: string): SafeParseResult<ListAgentsStreamOptions, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsThinking$inboundSchema: z.ZodType<ListAgentsThinking, z.ZodTypeDef, unknown>;
-export declare function listAgentsThinkingFromJSON(jsonString: string): SafeParseResult<ListAgentsThinking, SDKValidationError>;
+export declare const DataThinking$inboundSchema: z.ZodType<DataThinking, z.ZodTypeDef, unknown>;
+export declare function dataThinkingFromJSON(jsonString: string): SafeParseResult<DataThinking, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsToolChoiceType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsToolChoiceType>;
 /** @internal */
@@ -1188,31 +1194,28 @@ export declare function listAgentsToolChoice2FromJSON(jsonString: string): SafeP
 /** @internal */
 export declare const ListAgentsToolChoice1$inboundSchema: z.ZodNativeEnum<typeof ListAgentsToolChoice1>;
 /** @internal */
-export declare const ListAgentsToolChoice$inboundSchema: z.ZodType<ListAgentsToolChoice, z.ZodTypeDef, unknown>;
-export declare function listAgentsToolChoiceFromJSON(jsonString: string): SafeParseResult<ListAgentsToolChoice, SDKValidationError>;
+export declare const DataToolChoice$inboundSchema: z.ZodType<DataToolChoice, z.ZodTypeDef, unknown>;
+export declare function dataToolChoiceFromJSON(jsonString: string): SafeParseResult<DataToolChoice, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsModalities$inboundSchema: z.ZodNativeEnum<typeof ListAgentsModalities>;
+export declare const DataModalities$inboundSchema: z.ZodNativeEnum<typeof DataModalities>;
 /** @internal */
 export declare const ListAgentsId1$inboundSchema: z.ZodNativeEnum<typeof ListAgentsId1>;
 /** @internal */
-export declare const ListAgentsId$inboundSchema: z.ZodType<ListAgentsId, z.ZodTypeDef, unknown>;
-export declare function listAgentsIdFromJSON(jsonString: string): SafeParseResult<ListAgentsId, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsAgentsResponseExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsAgentsResponseExecuteOn>;
+export declare const DataId$inboundSchema: z.ZodType<DataId, z.ZodTypeDef, unknown>;
+export declare function dataIdFromJSON(jsonString: string): SafeParseResult<DataId, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsAgentsGuardrails$inboundSchema: z.ZodType<ListAgentsAgentsGuardrails, z.ZodTypeDef, unknown>;
-export declare function listAgentsAgentsGuardrailsFromJSON(jsonString: string): SafeParseResult<ListAgentsAgentsGuardrails, SDKValidationError>;
+export declare const ListAgentsDataAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataAgentsExecuteOn>;
 /** @internal */
-export declare const ListAgentsFallbacks$inboundSchema: z.ZodType<ListAgentsFallbacks, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbacksFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbacks, SDKValidationError>;
+export declare const ListAgentsDataGuardrails$inboundSchema: z.ZodType<ListAgentsDataGuardrails, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataGuardrailsFromJSON(jsonString: string): SafeParseResult<ListAgentsDataGuardrails, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsAgentsRetry$inboundSchema: z.ZodType<ListAgentsAgentsRetry, z.ZodTypeDef, unknown>;
-export declare function listAgentsAgentsRetryFromJSON(jsonString: string): SafeParseResult<ListAgentsAgentsRetry, SDKValidationError>;
+export declare const DataFallbacks$inboundSchema: z.ZodType<DataFallbacks, z.ZodTypeDef, unknown>;
+export declare function dataFallbacksFromJSON(jsonString: string): SafeParseResult<DataFallbacks, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsType>;
+export declare const ListAgentsDataAgentsResponseType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataAgentsResponseType>;
 /** @internal */
-export declare const ListAgentsCache$inboundSchema: z.ZodType<ListAgentsCache, z.ZodTypeDef, unknown>;
-export declare function listAgentsCacheFromJSON(jsonString: string): SafeParseResult<ListAgentsCache, SDKValidationError>;
+export declare const DataCache$inboundSchema: z.ZodType<DataCache, z.ZodTypeDef, unknown>;
+export declare function dataCacheFromJSON(jsonString: string): SafeParseResult<DataCache, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsLoadBalancerType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsLoadBalancerType>;
 /** @internal */
@@ -1222,24 +1225,17 @@ export declare function listAgentsLoadBalancerModelsFromJSON(jsonString: string)
 export declare const ListAgentsLoadBalancer1$inboundSchema: z.ZodType<ListAgentsLoadBalancer1, z.ZodTypeDef, unknown>;
 export declare function listAgentsLoadBalancer1FromJSON(jsonString: string): SafeParseResult<ListAgentsLoadBalancer1, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsLoadBalancer$inboundSchema: z.ZodType<ListAgentsLoadBalancer, z.ZodTypeDef, unknown>;
-export declare function listAgentsLoadBalancerFromJSON(jsonString: string): SafeParseResult<ListAgentsLoadBalancer, SDKValidationError>;
+export declare const DataLoadBalancer$inboundSchema: z.ZodType<DataLoadBalancer, z.ZodTypeDef, unknown>;
+export declare function dataLoadBalancerFromJSON(jsonString: string): SafeParseResult<DataLoadBalancer, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsTimeout$inboundSchema: z.ZodType<ListAgentsTimeout, z.ZodTypeDef, unknown>;
-export declare function listAgentsTimeoutFromJSON(jsonString: string): SafeParseResult<ListAgentsTimeout, SDKValidationError>;
+export declare const DataTimeout$inboundSchema: z.ZodType<DataTimeout, z.ZodTypeDef, unknown>;
+export declare function dataTimeoutFromJSON(jsonString: string): SafeParseResult<DataTimeout, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsParameters$inboundSchema: z.ZodType<ListAgentsParameters, z.ZodTypeDef, unknown>;
-export declare function listAgentsParametersFromJSON(jsonString: string): SafeParseResult<ListAgentsParameters, SDKValidationError>;
+export declare const DataParameters$inboundSchema: z.ZodType<DataParameters, z.ZodTypeDef, unknown>;
+export declare function dataParametersFromJSON(jsonString: string): SafeParseResult<DataParameters, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsRetry$inboundSchema: z.ZodType<ListAgentsRetry, z.ZodTypeDef, unknown>;
-export declare function listAgentsRetryFromJSON(jsonString: string): SafeParseResult<ListAgentsRetry, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsFallbackModelConfigurationVoice$inboundSchema: z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationVoice>;
-/** @internal */
-export declare const ListAgentsFallbackModelConfigurationFormat$inboundSchema: z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationFormat>;
-/** @internal */
-export declare const ListAgentsFallbackModelConfigurationAudio$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationAudio, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbackModelConfigurationAudioFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfigurationAudio, SDKValidationError>;
+export declare const DataRetry$inboundSchema: z.ZodType<DataRetry, z.ZodTypeDef, unknown>;
+export declare function dataRetryFromJSON(jsonString: string): SafeParseResult<DataRetry, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsResponseFormatAgentsResponseJsonSchema$inboundSchema: z.ZodType<ListAgentsResponseFormatAgentsResponseJsonSchema, z.ZodTypeDef, unknown>;
 export declare function listAgentsResponseFormatAgentsResponseJsonSchemaFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormatAgentsResponseJsonSchema, SDKValidationError>;
@@ -1261,9 +1257,6 @@ export declare const ListAgentsFallbackModelConfigurationReasoningEffort$inbound
 export declare const ListAgentsFallbackModelConfigurationStop$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationStop, z.ZodTypeDef, unknown>;
 export declare function listAgentsFallbackModelConfigurationStopFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfigurationStop, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsFallbackModelConfigurationStreamOptions$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationStreamOptions, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbackModelConfigurationStreamOptionsFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfigurationStreamOptions, SDKValidationError>;
-/** @internal */
 export declare const ListAgentsFallbackModelConfigurationThinking$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationThinking, z.ZodTypeDef, unknown>;
 export declare function listAgentsFallbackModelConfigurationThinkingFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfigurationThinking, SDKValidationError>;
 /** @internal */
@@ -1295,9 +1288,6 @@ export declare function listAgentsFallbackModelConfigurationGuardrailsFromJSON(j
 export declare const ListAgentsFallbackModelConfigurationFallbacks$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationFallbacks, z.ZodTypeDef, unknown>;
 export declare function listAgentsFallbackModelConfigurationFallbacksFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfigurationFallbacks, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsFallbackModelConfigurationAgentsRetry$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationAgentsRetry, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbackModelConfigurationAgentsRetryFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfigurationAgentsRetry, SDKValidationError>;
-/** @internal */
 export declare const ListAgentsFallbackModelConfigurationType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationType>;
 /** @internal */
 export declare const ListAgentsFallbackModelConfigurationCache$inboundSchema: z.ZodType<ListAgentsFallbackModelConfigurationCache, z.ZodTypeDef, unknown>;
@@ -1326,22 +1316,14 @@ export declare function listAgentsFallbackModelConfigurationRetryFromJSON(jsonSt
 export declare const ListAgentsFallbackModelConfiguration2$inboundSchema: z.ZodType<ListAgentsFallbackModelConfiguration2, z.ZodTypeDef, unknown>;
 export declare function listAgentsFallbackModelConfiguration2FromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfiguration2, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsFallbackModelConfiguration$inboundSchema: z.ZodType<ListAgentsFallbackModelConfiguration, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbackModelConfigurationFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfiguration, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsModel$inboundSchema: z.ZodType<ListAgentsModel, z.ZodTypeDef, unknown>;
-export declare function listAgentsModelFromJSON(jsonString: string): SafeParseResult<ListAgentsModel, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsTeamOfAgents$inboundSchema: z.ZodType<ListAgentsTeamOfAgents, z.ZodTypeDef, unknown>;
-export declare function listAgentsTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<ListAgentsTeamOfAgents, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsMetrics$inboundSchema: z.ZodType<ListAgentsMetrics, z.ZodTypeDef, unknown>;
-export declare function listAgentsMetricsFromJSON(jsonString: string): SafeParseResult<ListAgentsMetrics, SDKValidationError>;
+export declare const DataFallbackModelConfiguration$inboundSchema: z.ZodType<DataFallbackModelConfiguration, z.ZodTypeDef, unknown>;
+export declare function dataFallbackModelConfigurationFromJSON(jsonString: string): SafeParseResult<DataFallbackModelConfiguration, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsKnowledgeBases$inboundSchema: z.ZodType<ListAgentsKnowledgeBases, z.ZodTypeDef, unknown>;
-export declare function listAgentsKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<ListAgentsKnowledgeBases, SDKValidationError>;
+export declare const DataModel$inboundSchema: z.ZodType<DataModel, z.ZodTypeDef, unknown>;
+export declare function dataModelFromJSON(jsonString: string): SafeParseResult<DataModel, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsSource$inboundSchema: z.ZodNativeEnum<typeof ListAgentsSource>;
+export declare const Data1$inboundSchema: z.ZodType<Data1, z.ZodTypeDef, unknown>;
+export declare function data1FromJSON(jsonString: string): SafeParseResult<Data1, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsData$inboundSchema: z.ZodType<ListAgentsData, z.ZodTypeDef, unknown>;
 export declare function listAgentsDataFromJSON(jsonString: string): SafeParseResult<ListAgentsData, SDKValidationError>;