@azure/ai-projects 1.0.1 → 2.0.0-beta.1

package/dist/browser/models/models.d.ts

@@ -1,3 +1,2168 @@
+/**
+ * Represents an agent object.
+ * Contains the agent's unique identifier, name, and version information.
+ */
+export interface Agent {
+    /** The object type, which is always 'agent'. */
+    object: "agent";
+    /** The unique identifier of the agent. */
+    id: string;
+    /** The name of the agent. */
+    name: string;
+    /** The latest version of the agent. */
+    versions: {
+        latest: AgentVersion;
+    };
+}
+export declare function agentObjectDeserializer(item: any): Agent;
+/**
+ * Helper interface for agent version references.
+ */
+export interface _AgentVersions {
+    latest: AgentVersion;
+}
+export declare function _agentObjectVersionsDeserializer(item: any): _AgentVersions;
+/**
+ * Represents a specific version of an agent.
+ * Includes metadata, versioning, creation time, and agent definition.
+ */
+export interface AgentVersion {
+    /**
+     * Set of 16 key-value pairs that can be attached to an object. This can be
+     * useful for storing additional information about the object in a structured
+     * format, and querying for objects via API or the dashboard.
+     *
+     * Keys are strings with a maximum length of 64 characters. Values are strings
+     * with a maximum length of 512 characters.
+     */
+    metadata: Record<string, string>;
+    /** The object type, which is always 'agent.version'. */
+    object: "agent.version";
+    /** The unique identifier of the agent version. */
+    id: string;
+    /** The name of the agent. Name can be used to retrieve/update/delete the agent. */
+    name: string;
+    /** The version identifier of the agent. Agents are immutable and every update creates a new version while keeping the name same. */
+    version: string;
+    /** A human-readable description of the agent. */
+    description?: string;
+    /** The Unix timestamp (seconds) when the agent was created. */
+    created_at: Date;
+    /** The definition of the agent. */
+    definition: AgentDefinitionUnion;
+}
+export declare function agentVersionObjectDeserializer(item: any): AgentVersion;
+/**
+ * Base definition interface for agents.
+ * Contains the agent kind and optional RAI configuration.
+ */
+export interface AgentDefinition {
+    kind: AgentKind;
+    /** Configuration for Responsible AI (RAI) content filtering and safety features. */
+    rai_config?: RaiConfig;
+}
+export declare function agentDefinitionSerializer(item: AgentDefinition): any;
+export declare function agentDefinitionDeserializer(item: any): AgentDefinition;
+/**
+ * Union type for all agent definition types.
+ * Supports workflow, hosted, container app, and prompt agents.
+ */
+export type AgentDefinitionUnion = WorkflowAgentDefinition | HostedAgentDefinitionUnion | ContainerAppAgentDefinition | PromptAgentDefinition | AgentDefinition;
+export declare function agentDefinitionUnionSerializer(item: AgentDefinitionUnion): any;
+export declare function agentDefinitionUnionDeserializer(item: any): AgentDefinitionUnion;
+/**
+ * Defines the type/kind of agent.
+ * Determines which agent definition structure is used.
+ */
+export type AgentKind = "prompt" | "hosted" | "container_app" | "workflow";
+/** Configuration for Responsible AI (RAI) content filtering and safety features. */
+export interface RaiConfig {
+    /** The name of the RAI policy to apply. */
+    rai_policy_name: string;
+}
+export declare function raiConfigSerializer(item: RaiConfig): any;
+export declare function raiConfigDeserializer(item: any): RaiConfig;
+/** The workflow agent definition. */
+export interface WorkflowAgentDefinition extends AgentDefinition {
+    kind: "workflow";
+    /** The CSDL YAML definition of the workflow. */
+    workflow?: string;
+}
+export declare function workflowAgentDefinitionSerializer(item: WorkflowAgentDefinition): any;
+export declare function workflowAgentDefinitionDeserializer(item: any): WorkflowAgentDefinition;
+/** The hosted agent definition. */
+export interface HostedAgentDefinition extends AgentDefinition {
+    /** The kind of agent definition. */
+    kind: "hosted";
+    /**
+     * An array of tools the hosted agent's model may call while generating a response. You
+     * can specify which tool to use by setting the `tool_choice` parameter.
+     */
+    tools?: ToolUnion[];
+    /** The protocols that the agent supports for ingress communication of the containers. */
+    container_protocol_versions: ProtocolVersionRecord[];
+    /** The CPU configuration for the hosted agent. */
+    cpu: string;
+    /** The memory configuration for the hosted agent. */
+    memory: string;
+    /** Environment variables to set in the hosted agent container. */
+    environment_variables?: Record<string, string>;
+}
+export declare function hostedAgentDefinitionSerializer(item: HostedAgentDefinition): any;
+export declare function hostedAgentDefinitionDeserializer(item: any): HostedAgentDefinition;
+/** Alias for HostedAgentDefinitionUnion */
+export type HostedAgentDefinitionUnion = ImageBasedHostedAgentDefinition | HostedAgentDefinition;
+export declare function hostedAgentDefinitionUnionSerializer(item: HostedAgentDefinitionUnion): any;
+export declare function hostedAgentDefinitionUnionDeserializer(item: any): HostedAgentDefinitionUnion;
+export declare function toolUnionArraySerializer(result: Array<ToolUnion>): any[];
+export declare function toolUnionArrayDeserializer(result: Array<ToolUnion>): any[];
+/** model interface Tool */
+export interface Tool {
+    type: ToolType;
+}
+export declare function toolSerializer(item: Tool): any;
+export declare function toolDeserializer(item: any): Tool;
+/** Alias for ToolUnion */
+export type ToolUnion = FunctionTool | FileSearchTool | ComputerUsePreviewTool | WebSearchPreviewTool | CodeInterpreterTool | ImageGenTool | LocalShellTool | MCPTool | BingGroundingAgentTool | MicrosoftFabricAgentTool | SharepointAgentTool | AzureAISearchAgentTool | OpenApiAgentTool | BingCustomSearchAgentTool | BrowserAutomationAgentTool | AzureFunctionAgentTool | CaptureStructuredOutputsTool | A2ATool | MemorySearchTool | Tool;
+export declare function toolUnionSerializer(item: ToolUnion): any;
+export declare function toolUnionDeserializer(item: any): ToolUnion;
+/** A tool that can be used to generate a response. */
+export type ToolType = "file_search" | "function" | "computer_use_preview" | "web_search_preview" | "mcp" | "code_interpreter" | "image_generation" | "local_shell" | "bing_grounding" | "browser_automation_preview" | "fabric_dataagent_preview" | "sharepoint_grounding_preview" | "azure_ai_search" | "openapi" | "bing_custom_search_preview" | "capture_structured_outputs" | "a2a_preview" | "azure_function" | "memory_search";
+/**
+ * Function tool definition for agents.
+ * Allows the model to call functions defined in your code.
+ * Learn more about [function calling](https://platform.openai.com/docs/guides/function-calling).
+ */
+export interface FunctionTool extends Tool {
+    /** The type of the function tool. Always `function`. */
+    type: "function";
+    /** The name of the function to call. */
+    name: string;
+    /** A description of the function. Used by the model to determine whether or not to call the function. */
+    description?: string;
+    /** A JSON schema object describing the parameters of the function. */
+    parameters: unknown;
+    /** Whether to enforce strict parameter validation. Default `true`. */
+    strict: boolean;
+}
+export declare function functionToolSerializer(item: FunctionTool): any;
+export declare function functionToolDeserializer(item: any): FunctionTool;
+/**
+ * File search tool definition for agents.
+ * Searches for relevant content from uploaded files.
+ * Learn more about the [file search tool](https://platform.openai.com/docs/guides/tools-file-search).
+ */
+export interface FileSearchTool extends Tool {
+    /** The type of the file search tool. Always `file_search`. */
+    type: "file_search";
+    /** The IDs of the vector stores to search. */
+    vector_store_ids: string[];
+    /** The maximum number of results to return. This number should be between 1 and 50 inclusive. */
+    max_num_results?: number;
+    /** Ranking options for search. */
+    ranking_options?: RankingOptions;
+    /** A filter to apply. */
+    filters?: Filters;
+}
+export declare function fileSearchToolSerializer(item: FileSearchTool): any;
+export declare function fileSearchToolDeserializer(item: any): FileSearchTool;
+/**
+ * Ranking options for file search.
+ * Controls which ranker to use and the score threshold for results.
+ */
+export interface RankingOptions {
+    /** The ranker to use for the file search. */
+    ranker?: "auto" | "default-2024-11-15";
+    /** The score threshold for the file search, a number between 0 and 1. Numbers closer to 1 will attempt to return only the most relevant results, but may return fewer results. */
+    score_threshold?: number;
+}
+export declare function rankingOptionsSerializer(item: RankingOptions): any;
+export declare function rankingOptionsDeserializer(item: any): RankingOptions;
+/**
+ * Filter types for file search.
+ * Can be either a comparison filter or a compound filter combining multiple filters.
+ */
+export type Filters = ComparisonFilter | CompoundFilter;
+export declare function filtersSerializer(item: Filters): any;
+export declare function filtersDeserializer(item: any): Filters;
+/**
+ * Comparison filter for file search.
+ * Compares a specified attribute key to a given value using a comparison operation.
+ */
+export interface ComparisonFilter {
+    /**
+     * Specifies the comparison operator:
+     * `eq` (equal), `ne` (not equal), `gt` (greater than), `gte` (greater than or equal), `lt` (less than), `lte` (less than or equal).
+     */
+    type: "eq" | "ne" | "gt" | "gte" | "lt" | "lte";
+    /** The key to compare against the value. */
+    key: string;
+    /** The value to compare against the attribute key; supports string, number, or boolean types. */
+    value: string | number | boolean;
+}
+export declare function comparisonFilterSerializer(item: ComparisonFilter): any;
+export declare function comparisonFilterDeserializer(item: any): ComparisonFilter;
+/** Alias for _ComparisonFilterValue */
+export type _ComparisonFilterValue = string | number | boolean;
+export declare function _comparisonFilterValueSerializer(item: _ComparisonFilterValue): any;
+export declare function _comparisonFilterValueDeserializer(item: any): _ComparisonFilterValue;
+/**
+ * Compound filter for file search.
+ * Combines multiple filters using logical AND or OR operations.
+ */
+export interface CompoundFilter {
+    /** Type of operation: `and` or `or`. */
+    type: "and" | "or";
+    /** Array of filters to combine. Items can be `ComparisonFilter` or `CompoundFilter`. */
+    filters: (ComparisonFilter | CompoundFilter)[];
+}
+export declare function compoundFilterSerializer(item: CompoundFilter): any;
+export declare function compoundFilterDeserializer(item: any): CompoundFilter;
+export declare function _compoundFilterFilterArraySerializer(result: Array<_CompoundFilterFilter>): any[];
+export declare function _compoundFilterFilterArrayDeserializer(result: Array<_CompoundFilterFilter>): any[];
+/** Alias for _CompoundFilterFilter */
+export type _CompoundFilterFilter = ComparisonFilter | CompoundFilter;
+export declare function _compoundFilterFilterSerializer(item: _CompoundFilterFilter): any;
+export declare function _compoundFilterFilterDeserializer(item: any): _CompoundFilterFilter;
+/** A tool that controls a virtual computer. Learn more about the [computer tool](https://platform.openai.com/docs/guides/tools-computer-use). */
+export interface ComputerUsePreviewTool extends Tool {
+    /** The type of the computer use tool. Always `computer_use_preview`. */
+    type: "computer_use_preview";
+    /** The type of computer environment to control. */
+    environment: "windows" | "mac" | "linux" | "browser";
+    /** The width of the computer display. */
+    display_width: number;
+    /** The height of the computer display. */
+    display_height: number;
+}
+export declare function computerUsePreviewToolSerializer(item: ComputerUsePreviewTool): any;
+export declare function computerUsePreviewToolDeserializer(item: any): ComputerUsePreviewTool;
+/**
+ * Web search tool definition for agents.
+ * Note: web_search is not yet available via Azure OpenAI.
+ */
+export interface WebSearchPreviewTool extends Tool {
+    /** The type of the web search tool. One of `web_search_preview` or `web_search_preview_2025_03_11`. */
+    type: "web_search_preview";
+    /** The user's location. */
+    user_location?: LocationUnion;
+    /** High level guidance for the amount of context window space to use for the search. One of `low`, `medium`, or `high`. `medium` is the default. */
+    search_context_size?: "low" | "medium" | "high";
+}
+export declare function webSearchPreviewToolSerializer(item: WebSearchPreviewTool): any;
+export declare function webSearchPreviewToolDeserializer(item: any): WebSearchPreviewTool;
+/**
+ * Base interface for location information.
+ */
+export interface Location {
+    type: LocationType;
+}
+export declare function locationSerializer(item: Location): any;
+export declare function locationDeserializer(item: any): Location;
+/** Alias for LocationUnion */
+export type LocationUnion = ApproximateLocation | Location;
+export declare function locationUnionSerializer(item: LocationUnion): any;
+export declare function locationUnionDeserializer(item: any): LocationUnion;
+/**
+ * Type discriminator for location.
+ */
+export type LocationType = "approximate";
+/**
+ * Approximate location information for web search.
+ * Includes country, region, city, and timezone.
+ */
+export interface ApproximateLocation extends Location {
+    type: "approximate";
+    /** The country of the location. */
+    country?: string;
+    /** The region of the location. */
+    region?: string;
+    /** The city of the location. */
+    city?: string;
+    /** The timezone of the location. */
+    timezone?: string;
+}
+export declare function approximateLocationSerializer(item: ApproximateLocation): any;
+export declare function approximateLocationDeserializer(item: any): ApproximateLocation;
+/**
+ * Code interpreter tool definition for agents.
+ * Runs Python code to help generate responses to prompts.
+ */
+export interface CodeInterpreterTool extends Tool {
+    /** The type of the code interpreter tool. Always `code_interpreter`. */
+    type: "code_interpreter";
+    /**
+     * The code interpreter container. Can be a container ID or an object that
+     * specifies uploaded file IDs to make available to your code.
+     */
+    container: string | CodeInterpreterToolAuto;
+}
+export declare function codeInterpreterToolSerializer(item: CodeInterpreterTool): any;
+export declare function codeInterpreterToolDeserializer(item: any): CodeInterpreterTool;
+/** Alias for _CodeInterpreterToolContainer */
+export type _CodeInterpreterToolContainer = string | CodeInterpreterToolAuto;
+export declare function _codeInterpreterToolContainerSerializer(item: _CodeInterpreterToolContainer): any;
+export declare function _codeInterpreterToolContainerDeserializer(item: any): _CodeInterpreterToolContainer;
+/**
+ * Configuration for a code interpreter container. Optionally specify the IDs
+ * of the files to run the code on.
+ */
+export interface CodeInterpreterToolAuto {
+    /** Always `auto`. */
+    type: "auto";
+    /** An optional list of uploaded files to make available to your code. */
+    file_ids?: string[];
+}
+export declare function codeInterpreterToolAutoSerializer(item: CodeInterpreterToolAuto): any;
+export declare function codeInterpreterToolAutoDeserializer(item: any): CodeInterpreterToolAuto;
+/**
+ * Image generation tool definition for agents.
+ * Generates images using a model like `gpt-image-1`.
+ */
+export interface ImageGenTool extends Tool {
+    /** The type of the image generation tool. Always `image_generation`. */
+    type: "image_generation";
+    /** The image generation model to use. Default: `gpt-image-1`. */
+    model?: "gpt-image-1";
+    /**
+     * The quality of the generated image. One of `low`, `medium`, `high`,
+     * or `auto`. Default: `auto`.
+     */
+    quality?: "low" | "medium" | "high" | "auto";
+    /**
+     * The size of the generated image. One of `1024x1024`, `1024x1536`,
+     * `1536x1024`, or `auto`. Default: `auto`.
+     */
+    size?: "1024x1024" | "1024x1536" | "1536x1024" | "auto";
+    /**
+     * The output format of the generated image. One of `png`, `webp`, or
+     * `jpeg`. Default: `png`.
+     */
+    output_format?: "png" | "webp" | "jpeg";
+    /** Compression level for the output image. Default: 100. */
+    output_compression?: number;
+    /** Moderation level for the generated image. Default: `auto`. */
+    moderation?: "auto" | "low";
+    /**
+     * Background type for the generated image. One of `transparent`,
+     * `opaque`, or `auto`. Default: `auto`.
+     */
+    background?: "transparent" | "opaque" | "auto";
+    /**
+     * Optional mask for inpainting. Contains `image_url`
+     * (string, optional) and `file_id` (string, optional).
+     */
+    input_image_mask?: {
+        image_url?: string;
+        file_id?: string;
+    };
+    /** Number of partial images to generate in streaming mode, from 0 (default value) to 3. */
+    partial_images?: number;
+}
+export declare function imageGenToolSerializer(item: ImageGenTool): any;
+export declare function imageGenToolDeserializer(item: any): ImageGenTool;
+/**
+ * Input image mask configuration for image generation tool.
+ * Can specify either a base64-encoded image URL or a file ID.
+ */
+export interface _ImageGenToolInputImageMask {
+    /** Base64-encoded mask image. */
+    image_url?: string;
+    /** File ID for the mask image. */
+    file_id?: string;
+}
+export declare function _imageGenToolInputImageMaskSerializer(item: _ImageGenToolInputImageMask): any;
+export declare function _imageGenToolInputImageMaskDeserializer(item: any): _ImageGenToolInputImageMask;
+/**
+ * Local shell tool definition for agents.
+ * Allows the model to execute shell commands in a local environment.
+ */
+export interface LocalShellTool extends Tool {
+    /** The type of the local shell tool. Always `local_shell`. */
+    type: "local_shell";
+}
+export declare function localShellToolSerializer(item: LocalShellTool): any;
+export declare function localShellToolDeserializer(item: any): LocalShellTool;
+/**
+ * MCP (Model Context Protocol) tool definition for agents.
+ * Gives the model access to additional tools via remote MCP servers.
+ * [Learn more about MCP](https://platform.openai.com/docs/guides/tools-remote-mcp).
+ */
+export interface MCPTool extends Tool {
+    /** The type of the MCP tool. Always `mcp`. */
+    type: "mcp";
+    /** A label for this MCP server, used to identify it in tool calls. */
+    server_label: string;
+    /** The URL for the MCP server. */
+    server_url: string;
+    /**
+     * Optional HTTP headers to send to the MCP server. Use for authentication
+     * or other purposes.
+     */
+    headers?: Record<string, string>;
+    /** List of allowed tool names or a filter object. */
+    allowed_tools?: string[] | {
+        tool_names?: string[];
+    };
+    /** Specify which of the MCP server's tools require approval. */
+    require_approval?: {
+        /** A list of tools that always require approval. */
+        always?: {
+            /** List of tool names (snake_case) that always require approval. */
+            tool_names?: string[];
+        };
+        /** A list of tools that never require approval. */
+        never?: {
+            /** List of tool names (snake_case) that never require approval. */
+            tool_names?: string[];
+        };
+    } | "always" | "never";
+    /** The connection ID in the project for the MCP server. The connection stores authentication and other connection details needed to connect to the MCP server. */
+    project_connection_id?: string;
+}
+export declare function mcpToolSerializer(item: MCPTool): any;
+export declare function mcpToolDeserializer(item: any): MCPTool;
+/** Alias for _MCPToolAllowedTools */
+export type _MCPToolAllowedTools = string[] | {
+    tool_names?: string[];
+};
+export declare function _mcpToolAllowedToolsSerializer(item: _MCPToolAllowedTools): any;
+export declare function _mcpToolAllowedToolsDeserializer(item: any): _MCPToolAllowedTools;
+/** model interface _MCPToolAllowedTools1 */
+export interface _MCPToolAllowedTools1 {
+    /** List of allowed tool names. */
+    tool_names?: string[];
+}
+export declare function _mcpToolAllowedTools1Serializer(item: _MCPToolAllowedTools1): any;
+export declare function _mcpToolAllowedTools1Deserializer(item: any): _MCPToolAllowedTools1;
+/** Alias for _MCPToolRequireApproval */
+export type _MCPToolRequireApproval = {
+    always?: {
+        tool_names?: string[];
+    };
+    never?: {
+        tool_names?: string[];
+    };
+} | "always" | "never";
+export declare function _mcpToolRequireApprovalSerializer(item: _MCPToolRequireApproval): any;
+export declare function _mcpToolRequireApprovalDeserializer(item: any): _MCPToolRequireApproval;
+/** model interface _MCPToolRequireApproval1 */
+export interface _MCPToolRequireApproval1 {
+    /** A list of tools that always require approval. */
+    always?: {
+        tool_names?: string[];
+    };
+    /** A list of tools that never require approval. */
+    never?: {
+        tool_names?: string[];
+    };
+}
+export declare function _mcpToolRequireApproval1Serializer(item: _MCPToolRequireApproval1): any;
+export declare function _mcpToolRequireApproval1Deserializer(item: any): _MCPToolRequireApproval1;
+/** model interface _MCPToolRequireApprovalAlways */
+export interface _MCPToolRequireApprovalAlways {
+    /** List of tools that require approval. */
+    tool_names?: string[];
+}
+export declare function _mcpToolRequireApprovalAlwaysSerializer(item: _MCPToolRequireApprovalAlways): any;
+export declare function _mcpToolRequireApprovalAlwaysDeserializer(item: any): _MCPToolRequireApprovalAlways;
+/** model interface _MCPToolRequireApprovalNever */
+export interface _MCPToolRequireApprovalNever {
+    /** List of tools that do not require approval. */
+    tool_names?: string[];
+}
+export declare function _mcpToolRequireApprovalNeverSerializer(item: _MCPToolRequireApprovalNever): any;
+export declare function _mcpToolRequireApprovalNeverDeserializer(item: any): _MCPToolRequireApprovalNever;
+/** The input definition information for a bing grounding search tool as used to configure an agent. */
+export interface BingGroundingAgentTool extends Tool {
+    /** The object type, which is always 'bing_grounding'. */
+    type: "bing_grounding";
+    /** The bing grounding search tool parameters. */
+    bing_grounding: BingGroundingSearchToolParameters;
+}
+export declare function bingGroundingAgentToolSerializer(item: BingGroundingAgentTool): any;
+export declare function bingGroundingAgentToolDeserializer(item: any): BingGroundingAgentTool;
+/** The bing grounding search tool parameters. */
+export interface BingGroundingSearchToolParameters {
+    /**
+     * The search configurations attached to this tool. There can be a maximum of 1
+     * search configuration resource attached to the tool.
+     */
+    search_configurations: BingGroundingSearchConfiguration[];
+}
+export declare function bingGroundingSearchToolParametersSerializer(item: BingGroundingSearchToolParameters): any;
+export declare function bingGroundingSearchToolParametersDeserializer(item: any): BingGroundingSearchToolParameters;
+export declare function bingGroundingSearchConfigurationArraySerializer(result: Array<BingGroundingSearchConfiguration>): any[];
+export declare function bingGroundingSearchConfigurationArrayDeserializer(result: Array<BingGroundingSearchConfiguration>): any[];
+/** Search configuration for Bing Grounding */
+export interface BingGroundingSearchConfiguration {
+    /** Project connection id for grounding with bing search */
+    project_connection_id: string;
+    /** The market where the results come from. */
+    market?: string;
+    /** The language to use for user interface strings when calling Bing API. */
+    set_lang?: string;
+    /** The number of search results to return in the bing api response */
+    count?: number;
+    /** Filter search results by a specific time range. See [accepted values here](https://learn.microsoft.com/bing/search-apis/bing-web-search/reference/query-parameters). */
+    freshness?: string;
+}
+export declare function bingGroundingSearchConfigurationSerializer(item: BingGroundingSearchConfiguration): any;
+export declare function bingGroundingSearchConfigurationDeserializer(item: any): BingGroundingSearchConfiguration;
+/** The input definition information for a Microsoft Fabric tool as used to configure an agent. */
+export interface MicrosoftFabricAgentTool extends Tool {
+    /** The object type, which is always 'fabric_dataagent'. */
+    type: "fabric_dataagent_preview";
+    /** The fabric data agent tool parameters. */
+    fabric_dataagent_preview: FabricDataAgentToolParameters;
+}
+export declare function microsoftFabricAgentToolSerializer(item: MicrosoftFabricAgentTool): any;
+export declare function microsoftFabricAgentToolDeserializer(item: any): MicrosoftFabricAgentTool;
+/** The fabric data agent tool parameters. */
+export interface FabricDataAgentToolParameters {
+    /**
+     * The project connections attached to this tool. There can be a maximum of 1 connection
+     * resource attached to the tool.
+     */
+    project_connections?: ToolProjectConnection[];
+}
+export declare function fabricDataAgentToolParametersSerializer(item: FabricDataAgentToolParameters): any;
+export declare function fabricDataAgentToolParametersDeserializer(item: any): FabricDataAgentToolParameters;
+export declare function toolProjectConnectionArraySerializer(result: Array<ToolProjectConnection>): any[];
+export declare function toolProjectConnectionArrayDeserializer(result: Array<ToolProjectConnection>): any[];
+/** A project connection resource. */
+export interface ToolProjectConnection {
+    /** A project connection in a ToolProjectConnectionList attached to this tool. */
+    project_connection_id: string;
+}
+export declare function toolProjectConnectionSerializer(item: ToolProjectConnection): any;
+export declare function toolProjectConnectionDeserializer(item: any): ToolProjectConnection;
+/** The input definition information for a sharepoint tool as used to configure an agent. */
+export interface SharepointAgentTool extends Tool {
+    /** The object type, which is always 'sharepoint_grounding'. */
+    type: "sharepoint_grounding_preview";
+    /** The sharepoint grounding tool parameters. */
+    sharepoint_grounding_preview: SharepointGroundingToolParameters;
+}
+export declare function sharepointAgentToolSerializer(item: SharepointAgentTool): any;
+export declare function sharepointAgentToolDeserializer(item: any): SharepointAgentTool;
+/** The sharepoint grounding tool parameters. */
+export interface SharepointGroundingToolParameters {
+    /**
+     * The project connections attached to this tool. There can be a maximum of 1 connection
+     * resource attached to the tool.
+     */
+    project_connections?: ToolProjectConnection[];
+}
+export declare function sharepointGroundingToolParametersSerializer(item: SharepointGroundingToolParameters): any;
+export declare function sharepointGroundingToolParametersDeserializer(item: any): SharepointGroundingToolParameters;
+/** The input definition information for an Azure AI search tool as used to configure an agent. */
+export interface AzureAISearchAgentTool extends Tool {
+    /** The object type, which is always 'azure_ai_search'. */
+    type: "azure_ai_search";
+    /** The azure ai search index resource. */
+    azure_ai_search: AzureAISearchToolResource;
+}
+export declare function azureAISearchAgentToolSerializer(item: AzureAISearchAgentTool): any;
+export declare function azureAISearchAgentToolDeserializer(item: any): AzureAISearchAgentTool;
+/** A set of index resources used by the `azure_ai_search` tool. */
+export interface AzureAISearchToolResource {
+    /**
+     * The indices attached to this agent. There can be a maximum of 1 index
+     * resource attached to the agent.
+     */
+    indexes: AISearchIndexResource[];
+}
+export declare function azureAISearchToolResourceSerializer(item: AzureAISearchToolResource): any;
+export declare function azureAISearchToolResourceDeserializer(item: any): AzureAISearchToolResource;
+export declare function aiSearchIndexResourceArraySerializer(result: Array<AISearchIndexResource>): any[];
+export declare function aiSearchIndexResourceArrayDeserializer(result: Array<AISearchIndexResource>): any[];
+/** A AI Search Index resource. */
+export interface AISearchIndexResource {
+    /** An index connection ID in an IndexResource attached to this agent. */
+    project_connection_id?: string;
+    /** The name of an index in an IndexResource attached to this agent. */
+    index_name?: string;
+    /** Type of query in an AIIndexResource attached to this agent. */
+    query_type?: AzureAISearchQueryType;
+    /** Number of documents to retrieve from search and present to the model. */
+    top_k?: number;
+    /** filter string for search resource. [Learn more here](https://learn.microsoft.com/azure/search/search-filters). */
+    filter?: string;
+    /** Index asset id for search resource. */
+    index_asset_id?: string;
+}
+export declare function aiSearchIndexResourceSerializer(item: AISearchIndexResource): any;
+export declare function aiSearchIndexResourceDeserializer(item: any): AISearchIndexResource;
+/** Available query types for Azure AI Search tool. */
+export type AzureAISearchQueryType = "simple" | "semantic" | "vector" | "vector_simple_hybrid" | "vector_semantic_hybrid";
+/** The input definition information for an OpenAPI tool as used to configure an agent. */
+export interface OpenApiAgentTool extends Tool {
+    /** The object type, which is always 'openapi'. */
+    type: "openapi";
+    /** The openapi function definition. */
+    openapi: OpenApiFunctionDefinition;
+}
+export declare function openApiAgentToolSerializer(item: OpenApiAgentTool): any;
+export declare function openApiAgentToolDeserializer(item: any): OpenApiAgentTool;
+/** The input definition information for an openapi function. */
+export interface OpenApiFunctionDefinition {
+    /** The name of the function to be called. */
+    name: string;
+    /** A description of what the function does, used by the model to choose when and how to call the function. */
+    description?: string;
+    /** The openapi function shape, described as a JSON Schema object. */
+    spec: unknown;
+    /** Open API authentication details */
+    auth: OpenApiAuthDetailsUnion;
+    /** List of OpenAPI spec parameters that will use user-provided defaults */
+    default_params?: string[];
+    /** List of function definitions used by OpenApi tool */
+    readonly functions?: {
+        name: string;
+        description?: string;
+        parameters: unknown;
+    }[];
+}
+export declare function openApiFunctionDefinitionSerializer(item: OpenApiFunctionDefinition): any;
+export declare function openApiFunctionDefinitionDeserializer(item: any): OpenApiFunctionDefinition;
+/** authentication details for OpenApiFunctionDefinition */
+export interface OpenApiAuthDetails {
+    /** The type of authentication, must be anonymous/project_connection/managed_identity */
+    /** The discriminator possible values: anonymous, project_connection, managed_identity */
+    type: OpenApiAuthType;
+}
+export declare function openApiAuthDetailsSerializer(item: OpenApiAuthDetails): any;
+export declare function openApiAuthDetailsDeserializer(item: any): OpenApiAuthDetails;
+/** Alias for OpenApiAuthDetailsUnion */
+export type OpenApiAuthDetailsUnion = OpenApiAnonymousAuthDetails | OpenApiProjectConnectionAuthDetails | OpenApiManagedAuthDetails | OpenApiAuthDetails;
+export declare function openApiAuthDetailsUnionSerializer(item: OpenApiAuthDetailsUnion): any;
+export declare function openApiAuthDetailsUnionDeserializer(item: any): OpenApiAuthDetailsUnion;
+/**
+ * Authentication type for OpenApi endpoint. Allowed types are:
+ * - Anonymous (no authentication required)
+ * - Project Connection (requires project_connection_id to endpoint, as setup in Microsoft Foundry)
+ * - Managed_Identity (requires audience for identity based auth)
+ */
+export type OpenApiAuthType = "anonymous" | "project_connection" | "managed_identity";
+/** Security details for OpenApi anonymous authentication */
+export interface OpenApiAnonymousAuthDetails extends OpenApiAuthDetails {
+    /** The object type, which is always 'anonymous'. */
+    type: "anonymous";
+}
+export declare function openApiAnonymousAuthDetailsSerializer(item: OpenApiAnonymousAuthDetails): any;
+export declare function openApiAnonymousAuthDetailsDeserializer(item: any): OpenApiAnonymousAuthDetails;
+/** Security details for OpenApi project connection authentication */
+export interface OpenApiProjectConnectionAuthDetails extends OpenApiAuthDetails {
+    /** The object type, which is always 'project_connection'. */
+    type: "project_connection";
+    /** Project connection auth security details */
+    security_scheme: OpenApiProjectConnectionSecurityScheme;
+}
+export declare function openApiProjectConnectionAuthDetailsSerializer(item: OpenApiProjectConnectionAuthDetails): any;
+export declare function openApiProjectConnectionAuthDetailsDeserializer(item: any): OpenApiProjectConnectionAuthDetails;
+/** Security scheme for OpenApi managed_identity authentication */
+export interface OpenApiProjectConnectionSecurityScheme {
+    /** Project connection id for Project Connection auth type */
+    project_connection_id: string;
+}
+export declare function openApiProjectConnectionSecuritySchemeSerializer(item: OpenApiProjectConnectionSecurityScheme): any;
+export declare function openApiProjectConnectionSecuritySchemeDeserializer(item: any): OpenApiProjectConnectionSecurityScheme;
+/** Security details for OpenApi managed_identity authentication */
+export interface OpenApiManagedAuthDetails extends OpenApiAuthDetails {
+    /** The object type, which is always 'managed_identity'. */
+    type: "managed_identity";
+    /** Connection auth security details */
+    security_scheme: OpenApiManagedSecurityScheme;
+}
+export declare function openApiManagedAuthDetailsSerializer(item: OpenApiManagedAuthDetails): any;
+export declare function openApiManagedAuthDetailsDeserializer(item: any): OpenApiManagedAuthDetails;
+/** Security scheme for OpenApi managed_identity authentication */
+export interface OpenApiManagedSecurityScheme {
+    /** Authentication scope for managed_identity auth type */
+    audience: string;
+}
+export declare function openApiManagedSecuritySchemeSerializer(item: OpenApiManagedSecurityScheme): any;
+export declare function openApiManagedSecuritySchemeDeserializer(item: any): OpenApiManagedSecurityScheme;
+export declare function _openApiFunctionDefinitionFunctionArrayDeserializer(result: Array<_OpenApiFunctionDefinitionFunction>): any[];
+/** model interface _OpenApiFunctionDefinitionFunction */
+export interface _OpenApiFunctionDefinitionFunction {
+    /** The name of the function to be called. */
+    name: string;
+    /** A description of what the function does, used by the model to choose when and how to call the function. */
+    description?: string;
+    /** The parameters the functions accepts, described as a JSON Schema object. */
+    parameters: unknown;
+}
+export declare function _openApiFunctionDefinitionFunctionDeserializer(item: any): _OpenApiFunctionDefinitionFunction;
+/** The input definition information for a Bing custom search tool as used to configure an agent. */
+export interface BingCustomSearchAgentTool extends Tool {
+    /** The object type, which is always 'bing_custom_search'. */
+    type: "bing_custom_search_preview";
+    /** The bing custom search tool parameters. */
+    bing_custom_search_preview: BingCustomSearchToolParameters;
+}
+export declare function bingCustomSearchAgentToolSerializer(item: BingCustomSearchAgentTool): any;
+export declare function bingCustomSearchAgentToolDeserializer(item: any): BingCustomSearchAgentTool;
+/** The bing custom search tool parameters. */
+export interface BingCustomSearchToolParameters {
+    /**
+     * The project connections attached to this tool. There can be a maximum of 1 connection
+     * resource attached to the tool.
+     */
+    search_configurations: BingCustomSearchConfiguration[];
+}
+export declare function bingCustomSearchToolParametersSerializer(item: BingCustomSearchToolParameters): any;
+export declare function bingCustomSearchToolParametersDeserializer(item: any): BingCustomSearchToolParameters;
+export declare function bingCustomSearchConfigurationArraySerializer(result: Array<BingCustomSearchConfiguration>): any[];
+export declare function bingCustomSearchConfigurationArrayDeserializer(result: Array<BingCustomSearchConfiguration>): any[];
+/** A bing custom search configuration. */
+export interface BingCustomSearchConfiguration {
+    /** Project connection id for grounding with bing search */
+    project_connection_id: string;
+    /** Name of the custom configuration instance given to config. */
+    instance_name: string;
+    /** The market where the results come from. */
+    market?: string;
+    /** The language to use for user interface strings when calling Bing API. */
+    set_lang?: string;
+    /** The number of search results to return in the bing api response */
+    count?: number;
+    /** Filter search results by a specific time range. See [accepted values here](https://learn.microsoft.com/bing/search-apis/bing-web-search/reference/query-parameters). */
+    freshness?: string;
+}
+export declare function bingCustomSearchConfigurationSerializer(item: BingCustomSearchConfiguration): any;
+export declare function bingCustomSearchConfigurationDeserializer(item: any): BingCustomSearchConfiguration;
+/** The input definition information for a Browser Automation Tool, as used to configure an Agent. */
+export interface BrowserAutomationAgentTool extends Tool {
+    /** The object type, which is always 'browser_automation'. */
+    type: "browser_automation_preview";
+    /** The Browser Automation Tool parameters. */
+    browser_automation_preview: BrowserAutomationToolParameters;
+}
+export declare function browserAutomationAgentToolSerializer(item: BrowserAutomationAgentTool): any;
+export declare function browserAutomationAgentToolDeserializer(item: any): BrowserAutomationAgentTool;
+/** Definition of input parameters for the Browser Automation Tool. */
+export interface BrowserAutomationToolParameters {
+    /** The project connection parameters associated with the Browser Automation Tool. */
+    connection: BrowserAutomationToolConnectionParameters;
+}
+export declare function browserAutomationToolParametersSerializer(item: BrowserAutomationToolParameters): any;
+export declare function browserAutomationToolParametersDeserializer(item: any): BrowserAutomationToolParameters;
+/** Definition of input parameters for the connection used by the Browser Automation Tool. */
+export interface BrowserAutomationToolConnectionParameters {
+    /** The ID of the project connection to your Azure Playwright resource. */
+    project_connection_id: string;
+}
+export declare function browserAutomationToolConnectionParametersSerializer(item: BrowserAutomationToolConnectionParameters): any;
+export declare function browserAutomationToolConnectionParametersDeserializer(item: any): BrowserAutomationToolConnectionParameters;
+/** The input definition information for an Azure Function Tool, as used to configure an Agent. */
+export interface AzureFunctionAgentTool extends Tool {
+    /** The object type, which is always 'browser_automation'. */
+    type: "azure_function";
+    /** The Azure Function Tool definition. */
+    azure_function: AzureFunctionDefinition;
+}
+export declare function azureFunctionAgentToolSerializer(item: AzureFunctionAgentTool): any;
+export declare function azureFunctionAgentToolDeserializer(item: any): AzureFunctionAgentTool;
+/** The definition of Azure function. */
+export interface AzureFunctionDefinition {
+    /** The definition of azure function and its parameters. */
+    function: {
+        name: string;
+        description?: string;
+        parameters: unknown;
+    };
+    /** Input storage queue. The queue storage trigger runs a function as messages are added to it. */
+    input_binding: AzureFunctionBinding;
+    /** Output storage queue. The function writes output to this queue when the input items are processed. */
+    output_binding: AzureFunctionBinding;
+}
+export declare function azureFunctionDefinitionSerializer(item: AzureFunctionDefinition): any;
+export declare function azureFunctionDefinitionDeserializer(item: any): AzureFunctionDefinition;
+/** model interface _AzureFunctionDefinitionFunction */
+export interface _AzureFunctionDefinitionFunction {
+    /** The name of the function to be called. */
+    name: string;
+    /** A description of what the function does, used by the model to choose when and how to call the function. */
+    description?: string;
+    /** The parameters the functions accepts, described as a JSON Schema object. */
+    parameters: unknown;
+}
+export declare function _azureFunctionDefinitionFunctionSerializer(item: _AzureFunctionDefinitionFunction): any;
+export declare function _azureFunctionDefinitionFunctionDeserializer(item: any): _AzureFunctionDefinitionFunction;
+/** The structure for keeping storage queue name and URI. */
+export interface AzureFunctionBinding {
+    /** The type of binding, which is always 'storage_queue'. */
+    type: "storage_queue";
+    /** Storage queue. */
+    storage_queue: AzureFunctionStorageQueue;
+}
+export declare function azureFunctionBindingSerializer(item: AzureFunctionBinding): any;
+export declare function azureFunctionBindingDeserializer(item: any): AzureFunctionBinding;
+/** The structure for keeping storage queue name and URI. */
+export interface AzureFunctionStorageQueue {
+    /** URI to the Azure Storage Queue service allowing you to manipulate a queue. */
+    queue_service_endpoint: string;
+    /** The name of an Azure function storage queue. */
+    queue_name: string;
+}
+export declare function azureFunctionStorageQueueSerializer(item: AzureFunctionStorageQueue): any;
+export declare function azureFunctionStorageQueueDeserializer(item: any): AzureFunctionStorageQueue;
+/** A tool for capturing structured outputs */
+export interface CaptureStructuredOutputsTool extends Tool {
+    /** The type of the tool. Always `capture_structured_outputs`. */
+    type: "capture_structured_outputs";
+    /** The structured outputs to capture from the model. */
+    outputs: StructuredOutputDefinition;
+}
+export declare function captureStructuredOutputsToolSerializer(item: CaptureStructuredOutputsTool): any;
+export declare function captureStructuredOutputsToolDeserializer(item: any): CaptureStructuredOutputsTool;
+/**
+ * A structured output definition for agents.
+ * Defines a named output schema that the agent can produce.
+ */
+export interface StructuredOutputDefinition {
+    /** The name of the structured output. */
+    name: string;
+    /** A description of the output to emit. Used by the model to determine when to emit the output. */
+    description: string;
+    /** The JSON schema for the structured output. */
+    schema: Record<string, any>;
+    /** Whether to enforce strict validation. Default `true`. */
+    strict: boolean;
+}
+export declare function structuredOutputDefinitionSerializer(item: StructuredOutputDefinition): any;
+export declare function structuredOutputDefinitionDeserializer(item: any): StructuredOutputDefinition;
+/** An agent implementing the A2A protocol. */
+export interface A2ATool extends Tool {
+    /** The type of the tool. Always `a2a`. */
+    type: "a2a_preview";
+    /** Base URL of the agent. */
+    base_url?: string;
+    /**
+     * The path to the agent card relative to the `base_url`.
+     * If not provided, defaults to  `/.well-known/agent-card.json`
+     */
+    agent_card_path?: string;
+    /**
+     * The connection ID in the project for the A2A server.
+     * The connection stores authentication and other connection details needed to connect to the A2A server.
+     */
+    project_connection_id?: string;
+}
+export declare function a2AToolSerializer(item: A2ATool): any;
+export declare function a2AToolDeserializer(item: any): A2ATool;
+/** A tool for integrating memories into the agent. */
+export interface MemorySearchTool extends Tool {
+    /** The type of the tool. Always `memory_search`. */
+    type: "memory_search";
+    /** The name of the memory store to use. */
+    memory_store_name: string;
+    /**
+     * The namespace used to group and isolate memories, such as a user ID.
+     * Limits which memories can be retrieved or updated.
+     * Use special variable `{{$userId}}` to scope memories to the current signed-in user.
+     */
+    scope: string;
+    /** Options for searching the memory store. */
+    search_options?: MemorySearchOptions;
+    /** Time to wait before updating memories after inactivity (seconds). Default 300. */
+    update_delay?: number;
+}
+export declare function memorySearchToolSerializer(item: MemorySearchTool): any;
+export declare function memorySearchToolDeserializer(item: any): MemorySearchTool;
+/** Memory search options. */
+export interface MemorySearchOptions {
+    /** Maximum number of memory items to return. */
+    max_memories?: number;
+}
+export declare function memorySearchOptionsSerializer(item: MemorySearchOptions): any;
+export declare function memorySearchOptionsDeserializer(item: any): MemorySearchOptions;
+export declare function protocolVersionRecordArraySerializer(result: Array<ProtocolVersionRecord>): any[];
+export declare function protocolVersionRecordArrayDeserializer(result: Array<ProtocolVersionRecord>): any[];
+/** A record mapping for a single protocol and its version. */
+export interface ProtocolVersionRecord {
+    /** The protocol type. */
+    protocol: AgentProtocol;
+    /** The version string for the protocol, e.g. 'v0.1.1'. */
+    version: string;
+}
+export declare function protocolVersionRecordSerializer(item: ProtocolVersionRecord): any;
+export declare function protocolVersionRecordDeserializer(item: any): ProtocolVersionRecord;
+/** Type of AgentProtocol */
+export type AgentProtocol = "activity_protocol" | "responses";
+/** The image-based deployment definition for a hosted agent. */
+export interface ImageBasedHostedAgentDefinition extends HostedAgentDefinition {
+    kind: "hosted";
+    /** The image for the hosted agent. */
+    image: string;
+}
+export declare function imageBasedHostedAgentDefinitionSerializer(item: ImageBasedHostedAgentDefinition): any;
+export declare function imageBasedHostedAgentDefinitionDeserializer(item: any): ImageBasedHostedAgentDefinition;
+/** The container app agent definition. */
+export interface ContainerAppAgentDefinition extends AgentDefinition {
+    kind: "container_app";
+    /** The protocols that the agent supports for ingress communication of the containers. */
+    container_protocol_versions: ProtocolVersionRecord[];
+    /** The resource ID of the Azure Container App that hosts this agent. Not mutable across versions. */
+    container_app_resource_id: string;
+    /** The suffix to apply to the app subdomain when sending ingress to the agent. This can be a label (e.g., '---current'), a specific revision (e.g., '--0000001'), or empty to use the default endpoint for the container app. */
+    ingress_subdomain_suffix: string;
+}
+export declare function containerAppAgentDefinitionSerializer(item: ContainerAppAgentDefinition): any;
+export declare function containerAppAgentDefinitionDeserializer(item: any): ContainerAppAgentDefinition;
+/**
+ * Prompt-based agent definition.
+ * Defines an agent that uses a language model with custom instructions and tools.
+ */
+export interface PromptAgentDefinition extends AgentDefinition {
+    kind: "prompt";
+    /** The model deployment to use for this agent. */
+    model: string;
+    /** A system (or developer) message inserted into the model's context. */
+    instructions?: string;
+    /**
+     * 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.
+     * We generally recommend altering this or `top_p` but not both.
+     */
+    temperature?: number;
+    /**
+     * An alternative to sampling with temperature, called nucleus sampling,
+     * where the model considers the results of the tokens with top_p probability
+     * mass. So 0.1 means only the tokens comprising the top 10% probability mass
+     * are considered.
+     *
+     * We generally recommend altering this or `temperature` but not both.
+     */
+    top_p?: number;
+    reasoning?: Reasoning;
+    /**
+     * An array of tools the model may call while generating a response. You
+     * can specify which tool to use by setting the `tool_choice` parameter.
+     */
+    tools?: ToolUnion[];
+    /** Configuration options for a text response from the model. Can be plain text or structured JSON data. */
+    text?: {
+        format?: ResponseTextFormatConfigurationUnion;
+    };
+    /** Set of structured inputs that can participate in prompt template substitution or tool argument bindings. */
+    structured_inputs?: Record<string, StructuredInputDefinition>;
+}
+export declare function promptAgentDefinitionSerializer(item: PromptAgentDefinition): any;
+export declare function promptAgentDefinitionDeserializer(item: any): PromptAgentDefinition;
+/**
+ * **o-series models only**
+ *
+ * Configuration options for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+ */
+export interface Reasoning {
+    effort?: ReasoningEffort;
+    /**
+     * A summary of the reasoning performed by the model. This can be
+     * useful for debugging and understanding the model's reasoning process.
+     * One of `auto`, `concise`, or `detailed`.
+     */
+    summary?: "auto" | "concise" | "detailed";
+    /** **Deprecated**: use `summary` instead. A summary of the reasoning performed by the model. This can be useful for debugging and understanding the model's reasoning process. One of `auto`, `concise`, or `detailed`. */
+    generate_summary?: "auto" | "concise" | "detailed";
+}
+export declare function reasoningSerializer(item: Reasoning): any;
+export declare function reasoningDeserializer(item: any): Reasoning;
+/**
+ * **o-series models only**
+ *
+ * Constrains effort on reasoning for
+ * [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+ * Currently supported values are `low`, `medium`, and `high`. Reducing
+ * reasoning effort can result in faster responses and fewer tokens used
+ * on reasoning in a response.
+ */
+export type ReasoningEffort = "low" | "medium" | "high";
+/** model interface _PromptAgentDefinitionText */
+export interface _PromptAgentDefinitionText {
+    format?: ResponseTextFormatConfigurationUnion;
+}
+export declare function _promptAgentDefinitionTextSerializer(item: _PromptAgentDefinitionText): any;
+export declare function _promptAgentDefinitionTextDeserializer(item: any): _PromptAgentDefinitionText;
+/** model interface ResponseTextFormatConfiguration */
+export interface ResponseTextFormatConfiguration {
+    type: ResponseTextFormatConfigurationType;
+}
+export declare function responseTextFormatConfigurationSerializer(item: ResponseTextFormatConfiguration): any;
+export declare function responseTextFormatConfigurationDeserializer(item: any): ResponseTextFormatConfiguration;
+/** Alias for ResponseTextFormatConfigurationUnion */
+export type ResponseTextFormatConfigurationUnion = ResponseTextFormatConfigurationText | ResponseTextFormatConfigurationJson | ResponseTextFormatConfigurationJsonSchema | ResponseTextFormatConfiguration;
+export declare function responseTextFormatConfigurationUnionSerializer(item: ResponseTextFormatConfigurationUnion): any;
+export declare function responseTextFormatConfigurationUnionDeserializer(item: any): ResponseTextFormatConfigurationUnion;
+/**
+ * An object specifying the format that the model must output.
+ *
+ * Configuring `{ "type": "json_schema" }` enables Structured Outputs,
+ * which ensures the model will match your supplied JSON schema. Learn more in the
+ * [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+ *
+ * The default format is `{ "type": "text" }` with no additional options.
+ *
+ * **Not recommended for gpt-4o and newer models:**
+ *
+ * Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+ * ensures the message the model generates is valid JSON. Using `json_schema`
+ * is preferred for models that support it.
+ */
+export type ResponseTextFormatConfigurationType = "text" | "json_schema" | "json_object";
+/** model interface ResponseTextFormatConfigurationText */
+export interface ResponseTextFormatConfigurationText extends ResponseTextFormatConfiguration {
+    type: "text";
+}
+export declare function responseTextFormatConfigurationTextSerializer(item: ResponseTextFormatConfigurationText): any;
+export declare function responseTextFormatConfigurationTextDeserializer(item: any): ResponseTextFormatConfigurationText;
+/** model interface ResponseTextFormatConfigurationJson */
+export interface ResponseTextFormatConfigurationJson extends ResponseTextFormatConfiguration {
+    type: "json_object";
+}
+export declare function responseTextFormatConfigurationJsonObjectSerializer(item: ResponseTextFormatConfigurationJson): any;
+export declare function responseTextFormatConfigurationJsonObjectDeserializer(item: any): ResponseTextFormatConfigurationJson;
+/**
+ * JSON Schema response format. Used to generate structured JSON responses.
+ * Learn more about [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs).
+ */
+export interface ResponseTextFormatConfigurationJsonSchema extends ResponseTextFormatConfiguration {
+    /** The type of response format being defined. Always `json_schema`. */
+    type: "json_schema";
+    /**
+     * A description of what the response format is for, used by the model to
+     * determine how to respond in the format.
+     */
+    description?: string;
+    /**
+     * 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;
+    schema: ResponseFormatJsonSchemaSchema;
+    /**
+     * 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`. To learn more, read the [Structured Outputs
+     * guide](https://platform.openai.com/docs/guides/structured-outputs).
+     */
+    strict?: boolean;
+}
+/**
+ * The schema for the response format, described as a JSON Schema object.
+ * Learn how to build JSON schemas [here](https://json-schema.org/).
+ */
+export interface ResponseFormatJsonSchemaSchema {
+    /** Additional properties */
+    additionalProperties?: Record<string, any>;
+}
+export declare function responseFormatJsonSchemaSchemaSerializer(item: ResponseFormatJsonSchemaSchema): any;
+export declare function responseFormatJsonSchemaSchemaDeserializer(item: any): ResponseFormatJsonSchemaSchema;
+export declare function responseTextFormatConfigurationJsonSchemaSerializer(item: ResponseTextFormatConfigurationJsonSchema): any;
+export declare function responseTextFormatConfigurationJsonSchemaDeserializer(item: any): ResponseTextFormatConfigurationJsonSchema;
+export declare function structuredInputDefinitionRecordSerializer(item: Record<string, StructuredInputDefinition>): Record<string, any>;
+export declare function structuredInputDefinitionRecordDeserializer(item: Record<string, any>): Record<string, StructuredInputDefinition>;
+/** An structured input that can participate in prompt template substitutions and tool argument binding. */
+export interface StructuredInputDefinition {
+    /** A human-readable description of the input. */
+    description?: string;
+    /** The default value for the input if no run-time value is provided. */
+    default_value?: unknown;
+    /** When provided, the input value is bound to the specified tool arguments. */
+    tool_argument_bindings?: ToolArgumentBinding[];
+    /** The JSON schema for the structured input (optional). */
+    schema?: unknown;
+    /** Whether the input property is required when the agent is invoked. */
+    required?: boolean;
+}
+export declare function structuredInputDefinitionSerializer(item: StructuredInputDefinition): any;
+export declare function structuredInputDefinitionDeserializer(item: any): StructuredInputDefinition;
+export declare function toolArgumentBindingArraySerializer(result: Array<ToolArgumentBinding>): any[];
+export declare function toolArgumentBindingArrayDeserializer(result: Array<ToolArgumentBinding>): any[];
+/** model interface ToolArgumentBinding */
+export interface ToolArgumentBinding {
+    /** The name of the tool to participate in the argument binding. If not provided, then all tools with matching arguments will participate in binding. */
+    tool_name?: string;
+    /** The name of the argument within the tool. */
+    argument_name: string;
+}
+export declare function toolArgumentBindingSerializer(item: ToolArgumentBinding): any;
+export declare function toolArgumentBindingDeserializer(item: any): ToolArgumentBinding;
+/** Error response for API failures. */
+export interface ApiErrorResponse {
+    error: ApiError;
+}
+export declare function apiErrorResponseDeserializer(item: any): ApiErrorResponse;
+/** model interface ApiError */
+export interface ApiError {
+    /** The error code. */
+    code: string;
+    /** A human-readable description of the error. */
+    message: string;
+    /** The target of the error, if applicable. */
+    target?: string;
+    /** Additional details about the error. */
+    details: ApiError[];
+    /** The inner error, if any. */
+    innererror?: ApiInnerError;
+}
+export declare function apiErrorDeserializer(item: any): ApiError;
+export declare function apiErrorArrayDeserializer(result: Array<ApiError>): any[];
+/** model interface ApiInnerError */
+export interface ApiInnerError {
+    /** The error code. */
+    code: string;
+    /** The inner error, if any. */
+    innererror?: ApiInnerError;
+}
+export declare function apiInnerErrorDeserializer(item: any): ApiInnerError;
+/** A deleted agent Object */
+export interface DeleteAgentResponse {
+    /** The object type. Always 'agent.deleted'. */
+    object: "agent.deleted";
+    /** The name of the agent. */
+    name: string;
+    /** Whether the agent was successfully deleted. */
+    deleted: boolean;
+}
+export declare function deleteAgentResponseDeserializer(item: any): DeleteAgentResponse;
+/** The response data for a requested list of items. */
+export interface _AgentsPagedResultAgentObject {
+    /** The requested list of items. */
+    data: Agent[];
+    /** The first ID represented in this list. */
+    first_id?: string;
+    /** The last ID represented in this list. */
+    last_id?: string;
+    /** A value indicating whether there are additional values available not captured in this list. */
+    has_more: boolean;
+}
+export declare function _agentsPagedResultAgentObjectDeserializer(item: any): _AgentsPagedResultAgentObject;
+export declare function agentObjectArrayDeserializer(result: Array<Agent>): any[];
+/** A deleted agent version Object */
+export interface DeleteAgentVersionResponse {
+    /** The object type. Always 'agent.deleted'. */
+    object: "agent.version.deleted";
+    /** The name of the agent. */
+    name: string;
+    /** The version identifier of the agent. */
+    version: string;
+    /** Whether the agent was successfully deleted. */
+    deleted: boolean;
+}
+export declare function deleteAgentVersionResponseDeserializer(item: any): DeleteAgentVersionResponse;
+/** The response data for a requested list of items. */
+export interface _AgentsPagedResultAgentVersionObject {
+    /** The requested list of items. */
+    data: AgentVersion[];
+    /** The first ID represented in this list. */
+    first_id?: string;
+    /** The last ID represented in this list. */
+    last_id?: string;
+    /** A value indicating whether there are additional values available not captured in this list. */
+    has_more: boolean;
+}
+export declare function _agentsPagedResultAgentVersionObjectDeserializer(item: any): _AgentsPagedResultAgentVersionObject;
+export declare function agentVersionObjectArrayDeserializer(result: Array<AgentVersion>): any[];
+/** Base definition for memory store configurations. */
+export interface MemoryStoreDefinition {
+    /** The kind of the memory store. */
+    /** The discriminator possible values: default */
+    kind: MemoryStoreKind;
+}
+export declare function memoryStoreDefinitionSerializer(item: MemoryStoreDefinition): any;
+export declare function memoryStoreDefinitionDeserializer(item: any): MemoryStoreDefinition;
+/** Alias for MemoryStoreDefinitionUnion */
+export type MemoryStoreDefinitionUnion = MemoryStoreDefaultDefinition | MemoryStoreDefinition;
+export declare function memoryStoreDefinitionUnionSerializer(item: MemoryStoreDefinitionUnion): any;
+export declare function memoryStoreDefinitionUnionDeserializer(item: any): MemoryStoreDefinitionUnion;
+/** The type of memory store implementation to use. */
+export type MemoryStoreKind = "default";
+/** Default memory store implementation. */
+export interface MemoryStoreDefaultDefinition extends MemoryStoreDefinition {
+    /** The kind of the memory store. */
+    kind: "default";
+    /** The name or identifier of the chat completion model deployment used for memory processing. */
+    chat_model: string;
+    /** The name or identifier of the embedding model deployment used for memory processing. */
+    embedding_model: string;
+    /** Default memory store options. */
+    options?: MemoryStoreDefaultOptions;
+}
+export declare function memoryStoreDefaultDefinitionSerializer(item: MemoryStoreDefaultDefinition): any;
+export declare function memoryStoreDefaultDefinitionDeserializer(item: any): MemoryStoreDefaultDefinition;
+/** Default memory store configurations. */
+export interface MemoryStoreDefaultOptions {
+    /** Whether to enable user profile extraction and storage. Default is true. */
+    user_profile_enabled: boolean;
+    /** Specific categories or types of user profile information to extract and store. */
+    user_profile_details?: string;
+    /** Whether to enable chat summary extraction and storage. Default is true. */
+    chat_summary_enabled: boolean;
+}
+export declare function memoryStoreDefaultOptionsSerializer(item: MemoryStoreDefaultOptions): any;
+export declare function memoryStoreDefaultOptionsDeserializer(item: any): MemoryStoreDefaultOptions;
+/** A memory store that can store and retrieve user memories. */
+export interface MemoryStore {
+    /** The object type, which is always 'memory_store'. */
+    object: "memory_store";
+    /** The unique identifier of the memory store. */
+    id: string;
+    /** The Unix timestamp (seconds) when the memory store was created. */
+    created_at: Date;
+    /** The Unix timestamp (seconds) when the memory store was last updated. */
+    updated_at: Date;
+    /** The name of the memory store. */
+    name: string;
+    /** A human-readable description of the memory store. */
+    description?: string;
+    /** Arbitrary key-value metadata to associate with the memory store. */
+    metadata?: Record<string, string>;
+    /** The definition of the memory store. */
+    definition: MemoryStoreDefinitionUnion;
+}
+export declare function memoryStoreObjectDeserializer(item: any): MemoryStore;
+/** The response data for a requested list of items. */
+export interface _AgentsPagedResultMemoryStore {
+    /** The requested list of items. */
+    data: MemoryStore[];
+    /** The first ID represented in this list. */
+    first_id?: string;
+    /** The last ID represented in this list. */
+    last_id?: string;
+    /** A value indicating whether there are additional values available not captured in this list. */
+    has_more: boolean;
+}
+export declare function _agentsPagedResultMemoryStoreObjectDeserializer(item: any): _AgentsPagedResultMemoryStore;
+export declare function memoryStoreObjectArrayDeserializer(result: Array<MemoryStore>): any[];
+/** model interface DeleteMemoryStoreResponse */
+export interface DeleteMemoryStoreResponse {
+    /** The object type. Always 'memory_store.deleted'. */
+    object: "memory_store.deleted";
+    /** The name of the memory store. */
+    name: string;
+    /** Whether the memory store was successfully deleted. */
+    deleted: boolean;
+}
+export declare function deleteMemoryStoreResponseDeserializer(item: any): DeleteMemoryStoreResponse;
+/** Content item used to generate a response. */
+export interface ItemParam {
+    type: ItemType;
+}
+export declare function itemParamSerializer(item: ItemParam): any;
+/** Alias for ItemParamUnion */
+export type ItemParamUnion = ResponsesMessageItemParamUnion | FunctionToolCallOutputItemParam | FileSearchToolCallItemParam | ComputerToolCallItemParam | ComputerToolCallOutputItemParam | WebSearchToolCallItemParam | FunctionToolCallItemParam | ReasoningItemParam | ItemReferenceItemParam | ImageGenToolCallItemParam | CodeInterpreterToolCallItemParam | LocalShellToolCallItemParam | LocalShellToolCallOutputItemParam | MCPListToolsItemParam | MCPApprovalRequestItemParam | MCPApprovalResponseItemParam | MCPCallItemParam | MemorySearchToolCallItemParam | ItemParam;
+export declare function itemParamUnionSerializer(item: ItemParamUnion): any;
+/** Type of ItemType */
+export type ItemType = "message" | "file_search_call" | "function_call" | "function_call_output" | "computer_call" | "computer_call_output" | "web_search_call" | "reasoning" | "item_reference" | "image_generation_call" | "code_interpreter_call" | "local_shell_call" | "local_shell_call_output" | "mcp_list_tools" | "mcp_approval_request" | "mcp_approval_response" | "mcp_call" | "structured_outputs" | "workflow_action" | "memory_search_call" | "oauth_consent_request";
+/** A response message item, representing a role and content, as provided as client request parameters. */
+export interface ResponsesMessageItemParam extends ItemParam {
+    /** The type of the responses item, which is always 'message'. */
+    type: "message";
+    /** The role associated with the message. */
+    /** The discriminator possible values: user, system, developer, assistant */
+    role: ResponsesMessageRole;
+}
+export declare function responsesMessageItemParamSerializer(item: ResponsesMessageItemParam): any;
+/** Alias for ResponsesMessageItemParamUnion */
+export type ResponsesMessageItemParamUnion = ResponsesUserMessageItemParam | ResponsesSystemMessageItemParam | ResponsesDeveloperMessageItemParam | ResponsesAssistantMessageItemParam | ResponsesMessageItemParam;
+export declare function responsesMessageItemParamUnionSerializer(item: ResponsesMessageItemParamUnion): any;
+/** The collection of valid roles for responses message items. */
+export type ResponsesMessageRole = "system" | "developer" | "user" | "assistant";
+/** A message parameter item with the `user` role. */
+export interface ResponsesUserMessageItemParam extends ResponsesMessageItemParam {
+    /** The role of the message, which is always `user`. */
+    role: "user";
+    /** The content associated with the message. */
+    content: string | ItemContentUnion[];
+}
+export declare function responsesUserMessageItemParamSerializer(item: ResponsesUserMessageItemParam): any;
+/** Alias for _ResponsesUserMessageItemParamContent */
+export type _ResponsesUserMessageItemParamContent = string | ItemContentUnion[];
+export declare function _responsesUserMessageItemParamContentSerializer(item: _ResponsesUserMessageItemParamContent): any;
+export declare function itemContentUnionArraySerializer(result: Array<ItemContentUnion>): any[];
+/** model interface ItemContent */
+export interface ItemContent {
+    type: ItemContentType;
+}
+export declare function itemContentSerializer(item: ItemContent): any;
+/** Alias for ItemContentUnion */
+export type ItemContentUnion = ItemContentInputAudio | ItemContentOutputAudio | ItemContentRefusal | ItemContentInputText | ItemContentInputImage | ItemContentInputFile | ItemContentOutputText | ItemContent;
+export declare function itemContentUnionSerializer(item: ItemContentUnion): any;
+/** Multi-modal input and output contents. */
+export type ItemContentType = "input_text" | "input_audio" | "input_image" | "input_file" | "output_text" | "output_audio" | "refusal";
+/** An audio input to the model. */
+export interface ItemContentInputAudio extends ItemContent {
+    /** The type of the input item. Always `input_audio`. */
+    type: "input_audio";
+    /** Base64-encoded audio data. */
+    data: string;
+    /**
+     * The format of the audio data. Currently supported formats are `mp3` and
+     * `wav`.
+     */
+    format: "mp3" | "wav";
+}
+export declare function itemContentInputAudioSerializer(item: ItemContentInputAudio): any;
+/** An audio output from the model. */
+export interface ItemContentOutputAudio extends ItemContent {
+    /** The type of the output audio. Always `output_audio`. */
+    type: "output_audio";
+    /** Base64-encoded audio data from the model. */
+    data: string;
+    /** The transcript of the audio data from the model. */
+    transcript: string;
+}
+export declare function itemContentOutputAudioSerializer(item: ItemContentOutputAudio): any;
+/** A refusal from the model. */
+export interface ItemContentRefusal extends ItemContent {
+    /** The type of the refusal. Always `refusal`. */
+    type: "refusal";
+    /** The refusal explanationfrom the model. */
+    refusal: string;
+}
+export declare function itemContentRefusalSerializer(item: ItemContentRefusal): any;
+/** A text input to the model. */
+export interface ItemContentInputText extends ItemContent {
+    /** The type of the input item. Always `input_text`. */
+    type: "input_text";
+    /** The text input to the model. */
+    text: string;
+}
+export declare function itemContentInputTextSerializer(item: ItemContentInputText): any;
+/**
+ * Image input content for messages.
+ * Learn about [image inputs](https://platform.openai.com/docs/guides/vision).
+ */
+export interface ItemContentInputImage extends ItemContent {
+    /** The type of the input item. Always `input_image`. */
+    type: "input_image";
+    /** The URL of the image to be sent to the model. A fully qualified URL or base64 encoded image in a data URL. */
+    image_url?: string;
+    /** The ID of the file to be sent to the model. */
+    file_id?: string;
+    /** The detail level of the image to be sent to the model. One of `high`, `low`, or `auto`. Defaults to `auto`. */
+    detail?: "low" | "high" | "auto";
+}
+export declare function itemContentInputImageSerializer(item: ItemContentInputImage): any;
+/**
+ * File input content for messages.
+ * Can specify a file by ID or provide inline file data.
+ */
+export interface ItemContentInputFile extends ItemContent {
+    /** The type of the input item. Always `input_file`. */
+    type: "input_file";
+    /** The ID of the file to be sent to the model. */
+    file_id?: string;
+    /** The name of the file to be sent to the model. */
+    filename?: string;
+    /** The content of the file to be sent to the model. */
+    file_data?: string;
+}
+export declare function itemContentInputFileSerializer(item: ItemContentInputFile): any;
+/** A text output from the model. */
+export interface ItemContentOutputText extends ItemContent {
+    /** The type of the output text. Always `output_text`. */
+    type: "output_text";
+    /** The text output from the model. */
+    text: string;
+    /** The annotations of the text output. */
+    annotations: AnnotationUnion[];
+    logprobs?: LogProb[];
+}
+export declare function itemContentOutputTextSerializer(item: ItemContentOutputText): any;
+export declare function annotationUnionArraySerializer(result: Array<AnnotationUnion>): any[];
+/** model interface Annotation */
+export interface Annotation {
+    type: AnnotationType;
+}
+export declare function annotationSerializer(item: Annotation): any;
+/** Alias for AnnotationUnion */
+export type AnnotationUnion = AnnotationFileCitation | AnnotationUrlCitation | AnnotationFilePath | Annotation;
+export declare function annotationUnionSerializer(item: AnnotationUnion): any;
+/** Type of AnnotationType */
+export type AnnotationType = "file_citation" | "url_citation" | "file_path" | "container_file_citation";
+/** A citation to a file. */
+export interface AnnotationFileCitation extends Annotation {
+    /** The type of the file citation. Always `file_citation`. */
+    type: "file_citation";
+    /** The ID of the file. */
+    file_id: string;
+    /** The index of the file in the list of files. */
+    index: number;
+    /** The filename of the file cited. */
+    filename: string;
+}
+export declare function annotationFileCitationSerializer(item: AnnotationFileCitation): any;
+/** A citation for a web resource used to generate a model response. */
+export interface AnnotationUrlCitation extends Annotation {
+    /** The type of the URL citation. Always `url_citation`. */
+    type: "url_citation";
+    /** The URL of the web resource. */
+    url: string;
+    /** The index of the first character of the URL citation in the message. */
+    start_index: number;
+    /** The index of the last character of the URL citation in the message. */
+    end_index: number;
+    /** The title of the web resource. */
+    title: string;
+}
+export declare function annotationUrlCitationSerializer(item: AnnotationUrlCitation): any;
+/** A path to a file. */
+export interface AnnotationFilePath extends Annotation {
+    /** The type of the file path. Always `file_path`. */
+    type: "file_path";
+    /** The ID of the file. */
+    file_id: string;
+    /** The index of the file in the list of files. */
+    index: number;
+}
+export declare function annotationFilePathSerializer(item: AnnotationFilePath): any;
+export declare function logProbArraySerializer(result: Array<LogProb>): any[];
+/** The log probability of a token. */
+export interface LogProb {
+    token: string;
+    logprob: number;
+    bytes: number[];
+    top_logprobs: TopLogProb[];
+}
+export declare function logProbSerializer(item: LogProb): any;
+export declare function topLogProbArraySerializer(result: Array<TopLogProb>): any[];
+/** The top log probability of a token. */
+export interface TopLogProb {
+    token: string;
+    logprob: number;
+    bytes: number[];
+}
+export declare function topLogProbSerializer(item: TopLogProb): any;
+/** A message parameter item with the `system` role. */
+export interface ResponsesSystemMessageItemParam extends ResponsesMessageItemParam {
+    /** The role of the message, which is always `system`. */
+    role: "system";
+    /** The content associated with the message. */
+    content: string | ItemContentUnion[];
+}
+export declare function responsesSystemMessageItemParamSerializer(item: ResponsesSystemMessageItemParam): any;
+/** Alias for _ResponsesSystemMessageItemParamContent */
+export type _ResponsesSystemMessageItemParamContent = string | ItemContentUnion[];
+export declare function _responsesSystemMessageItemParamContentSerializer(item: _ResponsesSystemMessageItemParamContent): any;
+/** A message parameter item with the `developer` role. */
+export interface ResponsesDeveloperMessageItemParam extends ResponsesMessageItemParam {
+    /** The role of the message, which is always `developer`. */
+    role: "developer";
+    /** The content associated with the message. */
+    content: string | ItemContentUnion[];
+}
+export declare function responsesDeveloperMessageItemParamSerializer(item: ResponsesDeveloperMessageItemParam): any;
+/** Alias for _ResponsesDeveloperMessageItemParamContent */
+export type _ResponsesDeveloperMessageItemParamContent = string | ItemContentUnion[];
+export declare function _responsesDeveloperMessageItemParamContentSerializer(item: _ResponsesDeveloperMessageItemParamContent): any;
+/** A message parameter item with the `assistant` role. */
+export interface ResponsesAssistantMessageItemParam extends ResponsesMessageItemParam {
+    /** The role of the message, which is always `assistant`. */
+    role: "assistant";
+    /** The content associated with the message. */
+    content: string | ItemContentUnion[];
+}
+export declare function responsesAssistantMessageItemParamSerializer(item: ResponsesAssistantMessageItemParam): any;
+/** Alias for _ResponsesAssistantMessageItemParamContent */
+export type _ResponsesAssistantMessageItemParamContent = string | ItemContentUnion[];
+export declare function _responsesAssistantMessageItemParamContentSerializer(item: _ResponsesAssistantMessageItemParamContent): any;
+/**
+ * The output of a function tool call.
+ *
+ */
+export interface FunctionToolCallOutputItemParam extends ItemParam {
+    type: "function_call_output";
+    /** The unique ID of the function tool call generated by the model. */
+    call_id: string;
+    /** A JSON string of the output of the function tool call. */
+    output: string;
+}
+export declare function functionToolCallOutputItemParamSerializer(item: FunctionToolCallOutputItemParam): any;
+/**
+ * File search tool call item.
+ * Contains queries and results from a file search operation.
+ * See the [file search guide](https://platform.openai.com/docs/guides/tools-file-search) for more information.
+ */
+export interface FileSearchToolCallItemParam extends ItemParam {
+    type: "file_search_call";
+    /** The queries used to search for files. */
+    queries: string[];
+    /** The results of the file search tool call. */
+    results?: {
+        file_id?: string;
+        text?: string;
+        filename?: string;
+        attributes?: VectorStoreFileAttributes;
+        score?: number;
+    }[];
+}
+export declare function fileSearchToolCallItemParamSerializer(item: FileSearchToolCallItemParam): any;
+export declare function _fileSearchToolCallItemParamResultArraySerializer(result: Array<_FileSearchToolCallItemParamResult>): any[];
+/** model interface _FileSearchToolCallItemParamResult */
+export interface _FileSearchToolCallItemParamResult {
+    /** The unique ID of the file. */
+    file_id?: string;
+    /** The text that was retrieved from the file. */
+    text?: string;
+    /** The name of the file. */
+    filename?: string;
+    attributes?: VectorStoreFileAttributes;
+    /** The relevance score of the file - a value between 0 and 1. */
+    score?: number;
+}
+export declare function _fileSearchToolCallItemParamResultSerializer(item: _FileSearchToolCallItemParamResult): any;
+/**
+ * Set of 16 key-value pairs that can be attached to an object. This can be
+ * useful for storing additional information about the object in a structured
+ * format, and querying for objects via API or the dashboard. Keys are strings
+ * with a maximum length of 64 characters. Values are strings with a maximum
+ * length of 512 characters, booleans, or numbers.
+ */
+export interface VectorStoreFileAttributes {
+    /** Additional properties */
+    additionalProperties?: Record<string, string | boolean | number>;
+}
+export declare function vectorStoreFileAttributesSerializer(item: VectorStoreFileAttributes): any;
+/** Alias for _VectorStoreFileAttributesAdditionalProperty */
+export type _VectorStoreFileAttributesAdditionalProperty = string | boolean | number | number;
+export declare function _vectorStoreFileAttributesAdditionalPropertySerializer(item: _VectorStoreFileAttributesAdditionalProperty): any;
+/**
+ * A tool call to a computer use tool. See the
+ * [computer use guide](https://platform.openai.com/docs/guides/tools-computer-use) for more information.
+ *
+ */
+export interface ComputerToolCallItemParam extends ItemParam {
+    type: "computer_call";
+    /** An identifier used when responding to the tool call with output. */
+    call_id: string;
+    action: ComputerActionUnion;
+    /** The pending safety checks for the computer call. */
+    pending_safety_checks: ComputerToolCallSafetyCheck[];
+}
+export declare function computerToolCallItemParamSerializer(item: ComputerToolCallItemParam): any;
+/** model interface ComputerAction */
+export interface ComputerAction {
+    type: ComputerActionType;
+}
+export declare function computerActionSerializer(item: ComputerAction): any;
+/** Alias for ComputerActionUnion */
+export type ComputerActionUnion = ComputerActionClick | ComputerActionDoubleClick | ComputerActionDrag | ComputerActionMove | ComputerActionScreenshot | ComputerActionScroll | ComputerActionTypeKeys | ComputerActionWait | ComputerActionKeyPress | ComputerAction;
+export declare function computerActionUnionSerializer(item: ComputerActionUnion): any;
+/** Type of ComputerActionType */
+export type ComputerActionType = "screenshot" | "click" | "double_click" | "scroll" | "type" | "wait" | "keypress" | "drag" | "move";
+/** A click action. */
+export interface ComputerActionClick extends ComputerAction {
+    /**
+     * Specifies the event type. For a click action, this property is
+     * always set to `click`.
+     */
+    type: "click";
+    /** Indicates which mouse button was pressed during the click. One of `left`, `right`, `wheel`, `back`, or `forward`. */
+    button: "left" | "right" | "wheel" | "back" | "forward";
+    /** The x-coordinate where the click occurred. */
+    x: number;
+    /** The y-coordinate where the click occurred. */
+    y: number;
+}
+export declare function computerActionClickSerializer(item: ComputerActionClick): any;
+/** A double click action. */
+export interface ComputerActionDoubleClick extends ComputerAction {
+    /**
+     * Specifies the event type. For a double click action, this property is
+     * always set to `double_click`.
+     */
+    type: "double_click";
+    /** The x-coordinate where the double click occurred. */
+    x: number;
+    /** The y-coordinate where the double click occurred. */
+    y: number;
+}
+export declare function computerActionDoubleClickSerializer(item: ComputerActionDoubleClick): any;
+/** A drag action. */
+export interface ComputerActionDrag extends ComputerAction {
+    /**
+     * Specifies the event type. For a drag action, this property is
+     * always set to `drag`.
+     */
+    type: "drag";
+    /**
+     * An array of coordinates representing the path of the drag action. Coordinates will appear as an array
+     * of objects, eg
+     * ```
+     * [
+     *   { x: 100, y: 200 },
+     *   { x: 200, y: 300 }
+     * ]
+     * ```
+     */
+    path: Coordinate[];
+}
+export declare function computerActionDragSerializer(item: ComputerActionDrag): any;
+export declare function coordinateArraySerializer(result: Array<Coordinate>): any[];
+/** An x/y coordinate pair, e.g. `{ x: 100, y: 200 }`. */
+export interface Coordinate {
+    /** The x-coordinate. */
+    x: number;
+    /** The y-coordinate. */
+    y: number;
+}
+export declare function coordinateSerializer(item: Coordinate): any;
+/** A mouse move action. */
+export interface ComputerActionMove extends ComputerAction {
+    /**
+     * Specifies the event type. For a move action, this property is
+     * always set to `move`.
+     */
+    type: "move";
+    /** The x-coordinate to move to. */
+    x: number;
+    /** The y-coordinate to move to. */
+    y: number;
+}
+export declare function computerActionMoveSerializer(item: ComputerActionMove): any;
+/** A screenshot action. */
+export interface ComputerActionScreenshot extends ComputerAction {
+    /**
+     * Specifies the event type. For a screenshot action, this property is
+     * always set to `screenshot`.
+     */
+    type: "screenshot";
+}
+export declare function computerActionScreenshotSerializer(item: ComputerActionScreenshot): any;
+/** A scroll action. */
+export interface ComputerActionScroll extends ComputerAction {
+    /**
+     * Specifies the event type. For a scroll action, this property is
+     * always set to `scroll`.
+     */
+    type: "scroll";
+    /** The x-coordinate where the scroll occurred. */
+    x: number;
+    /** The y-coordinate where the scroll occurred. */
+    y: number;
+    /** The horizontal scroll distance. */
+    scroll_x: number;
+    /** The vertical scroll distance. */
+    scroll_y: number;
+}
+export declare function computerActionScrollSerializer(item: ComputerActionScroll): any;
+/** An action to type in text. */
+export interface ComputerActionTypeKeys extends ComputerAction {
+    /**
+     * Specifies the event type. For a type action, this property is
+     * always set to `type`.
+     */
+    type: "type";
+    /** The text to type. */
+    text: string;
+}
+export declare function computerActionTypeKeysSerializer(item: ComputerActionTypeKeys): any;
+/** A wait action. */
+export interface ComputerActionWait extends ComputerAction {
+    /**
+     * Specifies the event type. For a wait action, this property is
+     * always set to `wait`.
+     */
+    type: "wait";
+}
+export declare function computerActionWaitSerializer(item: ComputerActionWait): any;
+/** A collection of keypresses the model would like to perform. */
+export interface ComputerActionKeyPress extends ComputerAction {
+    /**
+     * Specifies the event type. For a keypress action, this property is
+     * always set to `keypress`.
+     */
+    type: "keypress";
+    /**
+     * The combination of keys the model is requesting to be pressed. This is an
+     * array of strings, each representing a key.
+     */
+    keys: string[];
+}
+export declare function computerActionKeyPressSerializer(item: ComputerActionKeyPress): any;
+export declare function computerToolCallSafetyCheckArraySerializer(result: Array<ComputerToolCallSafetyCheck>): any[];
+/** A pending safety check for the computer call. */
+export interface ComputerToolCallSafetyCheck {
+    /** The ID of the pending safety check. */
+    id: string;
+    /** The type of the pending safety check. */
+    code: string;
+    /** Details about the pending safety check. */
+    message: string;
+}
+export declare function computerToolCallSafetyCheckSerializer(item: ComputerToolCallSafetyCheck): any;
+/**
+ * The output of a computer tool call.
+ *
+ */
+export interface ComputerToolCallOutputItemParam extends ItemParam {
+    type: "computer_call_output";
+    /** The ID of the computer tool call that produced the output. */
+    call_id: string;
+    /**
+     * The safety checks reported by the API that have been acknowledged by the
+     * developer.
+     */
+    acknowledged_safety_checks?: ComputerToolCallSafetyCheck[];
+    output: ComputerToolCallOutputItemOutputUnion;
+}
+export declare function computerToolCallOutputItemParamSerializer(item: ComputerToolCallOutputItemParam): any;
+/** model interface ComputerToolCallOutputItemOutput */
+export interface ComputerToolCallOutputItemOutput {
+    type: ComputerToolCallOutputItemOutputType;
+}
+export declare function computerToolCallOutputItemOutputSerializer(item: ComputerToolCallOutputItemOutput): any;
+/** Alias for ComputerToolCallOutputItemOutputUnion */
+export type ComputerToolCallOutputItemOutputUnion = ComputerToolCallOutputItemOutputComputerScreenshot | ComputerToolCallOutputItemOutput;
+export declare function computerToolCallOutputItemOutputUnionSerializer(item: ComputerToolCallOutputItemOutputUnion): any;
+/** A computer screenshot image used with the computer use tool. */
+export type ComputerToolCallOutputItemOutputType = "computer_screenshot";
+/** model interface ComputerToolCallOutputItemOutputComputerScreenshot */
+export interface ComputerToolCallOutputItemOutputComputerScreenshot extends ComputerToolCallOutputItemOutput {
+    type: "computer_screenshot";
+    /** The URL of the screenshot image. */
+    image_url?: string;
+    /** The ID of the screenshot file. */
+    file_id?: string;
+}
+export declare function computerToolCallOutputItemOutputComputerScreenshotSerializer(item: ComputerToolCallOutputItemOutputComputerScreenshot): any;
+/**
+ * The results of a web search tool call. See the
+ * [web search guide](https://platform.openai.com/docs/guides/tools-web-search) for more information.
+ *
+ */
+export interface WebSearchToolCallItemParam extends ItemParam {
+    type: "web_search_call";
+    /**
+     * An object describing the specific action taken in this web search call.
+     * Includes details on how the model used the web (search, open_page, find).
+     */
+    action: WebSearchActionUnion;
+}
+export declare function webSearchToolCallItemParamSerializer(item: WebSearchToolCallItemParam): any;
+/** model interface WebSearchAction */
+export interface WebSearchAction {
+    type: WebSearchActionType;
+}
+export declare function webSearchActionSerializer(item: WebSearchAction): any;
+/** Alias for WebSearchActionUnion */
+export type WebSearchActionUnion = WebSearchActionFind | WebSearchActionOpenPage | WebSearchActionSearch | WebSearchAction;
+export declare function webSearchActionUnionSerializer(item: WebSearchActionUnion): any;
+/** Type of WebSearchActionType */
+export type WebSearchActionType = "search" | "open_page" | "find";
+/** Action type "find": Searches for a pattern within a loaded page. */
+export interface WebSearchActionFind extends WebSearchAction {
+    /** The action type. */
+    type: "find";
+    /** The URL of the page searched for the pattern. */
+    url: string;
+    /** The pattern or text to search for within the page. */
+    pattern: string;
+}
+export declare function webSearchActionFindSerializer(item: WebSearchActionFind): any;
+/** Action type "open_page" - Opens a specific URL from search results. */
+export interface WebSearchActionOpenPage extends WebSearchAction {
+    /** The action type. */
+    type: "open_page";
+    /** The URL opened by the model. */
+    url: string;
+}
+export declare function webSearchActionOpenPageSerializer(item: WebSearchActionOpenPage): any;
+/** Action type "search" - Performs a web search query. */
+export interface WebSearchActionSearch extends WebSearchAction {
+    /** The action type. */
+    type: "search";
+    /** The search query. */
+    query: string;
+    /** The sources used in the search. */
+    sources?: WebSearchActionSearchSources[];
+}
+export declare function webSearchActionSearchSerializer(item: WebSearchActionSearch): any;
+export declare function webSearchActionSearchSourcesArraySerializer(result: Array<WebSearchActionSearchSources>): any[];
+/** model interface WebSearchActionSearchSources */
+export interface WebSearchActionSearchSources {
+    type: "url";
+    url: string;
+}
+export declare function webSearchActionSearchSourcesSerializer(item: WebSearchActionSearchSources): any;
+/**
+ * A tool call to run a function. See the
+ * [function calling guide](https://platform.openai.com/docs/guides/function-calling) for more information.
+ *
+ */
+export interface FunctionToolCallItemParam extends ItemParam {
+    type: "function_call";
+    /** The unique ID of the function tool call generated by the model. */
+    call_id: string;
+    /** The name of the function to run. */
+    name: string;
+    /** A JSON string of the arguments to pass to the function. */
+    arguments: string;
+}
+export declare function functionToolCallItemParamSerializer(item: FunctionToolCallItemParam): any;
+/**
+ * Reasoning item parameter for o-series models.
+ * Contains the chain of thought used by a reasoning model while generating a response.
+ * Be sure to include these items in your `input` to the Responses API
+ * for subsequent turns of a conversation if you are manually
+ * [managing conversation state](https://platform.openai.com/docs/guides/conversation-state).
+ */
+export interface ReasoningItemParam extends ItemParam {
+    type: "reasoning";
+    /**
+     * The encrypted content of the reasoning item - populated when a response is
+     * generated with `reasoning.encrypted_content` in the `include` parameter.
+     */
+    encrypted_content?: string;
+    /** Reasoning text contents. */
+    summary: ReasoningItemSummaryPartUnion[];
+}
+export declare function reasoningItemParamSerializer(item: ReasoningItemParam): any;
+export declare function reasoningItemSummaryPartUnionArraySerializer(result: Array<ReasoningItemSummaryPartUnion>): any[];
+/** model interface ReasoningItemSummaryPart */
+export interface ReasoningItemSummaryPart {
+    type: ReasoningItemSummaryPartType;
+}
+export declare function reasoningItemSummaryPartSerializer(item: ReasoningItemSummaryPart): any;
+/** Alias for ReasoningItemSummaryPartUnion */
+export type ReasoningItemSummaryPartUnion = ReasoningItemSummaryTextPart | ReasoningItemSummaryPart;
+export declare function reasoningItemSummaryPartUnionSerializer(item: ReasoningItemSummaryPartUnion): any;
+/** Type of ReasoningItemSummaryPartType */
+export type ReasoningItemSummaryPartType = "summary_text";
+/** model interface ReasoningItemSummaryTextPart */
+export interface ReasoningItemSummaryTextPart extends ReasoningItemSummaryPart {
+    type: "summary_text";
+    text: string;
+}
+export declare function reasoningItemSummaryTextPartSerializer(item: ReasoningItemSummaryTextPart): any;
+/** An internal identifier for an item to reference. */
+export interface ItemReferenceItemParam extends ItemParam {
+    type: "item_reference";
+    /** The service-originated ID of the previously generated response item being referenced. */
+    id: string;
+}
+export declare function itemReferenceItemParamSerializer(item: ItemReferenceItemParam): any;
+/**
+ * Image generation tool call item.
+ * Contains the request made by the model to generate an image.
+ */
+export interface ImageGenToolCallItemParam extends ItemParam {
+    type: "image_generation_call";
+    /** The generated image encoded in base64. */
+    result: string;
+}
+export declare function imageGenToolCallItemParamSerializer(item: ImageGenToolCallItemParam): any;
+/**
+ * Code interpreter tool call item.
+ * Contains code execution request and outputs from the code interpreter.
+ */
+export interface CodeInterpreterToolCallItemParam extends ItemParam {
+    type: "code_interpreter_call";
+    /** The ID of the container used to run the code. */
+    container_id: string;
+    /** The code to run. */
+    code: string;
+    /**
+     * The outputs generated by the code interpreter, such as logs or images.
+     */
+    outputs: CodeInterpreterOutputUnion[];
+}
+export declare function codeInterpreterToolCallItemParamSerializer(item: CodeInterpreterToolCallItemParam): any;
+export declare function codeInterpreterOutputUnionArraySerializer(result: Array<CodeInterpreterOutputUnion>): any[];
+/** model interface CodeInterpreterOutput */
+export interface CodeInterpreterOutput {
+    type: CodeInterpreterOutputType;
+}
+export declare function codeInterpreterOutputSerializer(item: CodeInterpreterOutput): any;
+/** Alias for CodeInterpreterOutputUnion */
+export type CodeInterpreterOutputUnion = CodeInterpreterOutputImage | CodeInterpreterOutputLogs | CodeInterpreterOutput;
+export declare function codeInterpreterOutputUnionSerializer(item: CodeInterpreterOutputUnion): any;
+/** Type of CodeInterpreterOutputType */
+export type CodeInterpreterOutputType = "logs" | "image";
+/** The image output from the code interpreter. */
+export interface CodeInterpreterOutputImage extends CodeInterpreterOutput {
+    /** The type of the output. Always 'image'. */
+    type: "image";
+    /** The URL of the image output from the code interpreter. */
+    url: string;
+}
+export declare function codeInterpreterOutputImageSerializer(item: CodeInterpreterOutputImage): any;
+/** The logs output from the code interpreter. */
+export interface CodeInterpreterOutputLogs extends CodeInterpreterOutput {
+    /** The type of the output. Always 'logs'. */
+    type: "logs";
+    /** The logs output from the code interpreter. */
+    logs: string;
+}
+export declare function codeInterpreterOutputLogsSerializer(item: CodeInterpreterOutputLogs): any;
+/**
+ * A tool call to run a command on the local shell.
+ *
+ */
+export interface LocalShellToolCallItemParam extends ItemParam {
+    type: "local_shell_call";
+    /** The unique ID of the local shell tool call generated by the model. */
+    call_id: string;
+    action: LocalShellExecAction;
+}
+export declare function localShellToolCallItemParamSerializer(item: LocalShellToolCallItemParam): any;
+/**
+ * Execute a shell command action.
+ * Defines the command, environment, and execution context for local shell execution.
+ */
+export interface LocalShellExecAction {
+    /** The type of the local shell action. Always `exec`. */
+    type: "exec";
+    /** The command to run. */
+    command: string[];
+    /** Optional timeout in milliseconds for the command. */
+    timeout_ms?: number;
+    /** Optional working directory to run the command in. */
+    working_directory?: string;
+    /** Environment variables to set for the command. */
+    env: Record<string, string>;
+    /** Optional user to run the command as. */
+    user?: string;
+}
+export declare function localShellExecActionSerializer(item: LocalShellExecAction): any;
+/**
+ * The output of a local shell tool call.
+ *
+ */
+export interface LocalShellToolCallOutputItemParam extends ItemParam {
+    type: "local_shell_call_output";
+    /** A JSON string of the output of the local shell tool call. */
+    output: string;
+}
+export declare function localShellToolCallOutputItemParamSerializer(item: LocalShellToolCallOutputItemParam): any;
+/**
+ * MCP tool list item.
+ * Contains the list of tools available on an MCP server.
+ */
+export interface MCPListToolsItemParam extends ItemParam {
+    type: "mcp_list_tools";
+    /** The label of the MCP server. */
+    server_label: string;
+    /** The tools available on the server. */
+    tools: MCPListToolsTool[];
+    /** Error message if the server could not list tools. */
+    error?: string;
+}
+export declare function mcpListToolsItemParamSerializer(item: MCPListToolsItemParam): any;
+export declare function mcpListToolsToolArraySerializer(result: Array<MCPListToolsTool>): any[];
+/**
+ * A tool available on an MCP server.
+ * Describes a single tool with its name, description, input schema, and annotations.
+ */
+export interface MCPListToolsTool {
+    /** The name of the tool. */
+    name: string;
+    /** The description of the tool. */
+    description?: string;
+    /** The JSON schema describing the tool's input. */
+    input_schema: unknown;
+    /** Additional annotations about the tool. */
+    annotations?: unknown;
+}
+export declare function mcpListToolsToolSerializer(item: MCPListToolsTool): any;
+/**
+ * A request for human approval of a tool invocation.
+ *
+ */
+export interface MCPApprovalRequestItemParam extends ItemParam {
+    type: "mcp_approval_request";
+    /** The label of the MCP server making the request. */
+    server_label: string;
+    /** The name of the tool to run. */
+    name: string;
+    /** A JSON string of arguments for the tool. */
+    arguments: string;
+}
+export declare function mcpApprovalRequestItemParamSerializer(item: MCPApprovalRequestItemParam): any;
+/**
+ * MCP approval response item.
+ * Contains the response to an MCP tool approval request.
+ */
+export interface MCPApprovalResponseItemParam extends ItemParam {
+    type: "mcp_approval_response";
+    /** The ID of the approval request being answered. */
+    approval_request_id: string;
+    /** Whether the request was approved. */
+    approve: boolean;
+    /** Optional reason for the decision. */
+    reason?: string;
+}
+export declare function mcpApprovalResponseItemParamSerializer(item: MCPApprovalResponseItemParam): any;
+/**
+ * MCP tool call item.
+ * Contains an invocation of a tool on an MCP server with its arguments and results.
+ */
+export interface MCPCallItemParam extends ItemParam {
+    type: "mcp_call";
+    /** The label of the MCP server running the tool. */
+    server_label: string;
+    /** The name of the tool that was run. */
+    name: string;
+    /** A JSON string of the arguments passed to the tool. */
+    arguments: string;
+    /** The output from the tool call. */
+    output?: string;
+    /** The error from the tool call, if any. */
+    error?: string;
+}
+export declare function mcpCallItemParamSerializer(item: MCPCallItemParam): any;
+/**
+ * Memory search tool call item.
+ * Contains results from a memory store search operation.
+ */
+export interface MemorySearchToolCallItemParam extends ItemParam {
+    type: "memory_search_call";
+    /** The results returned from the memory search. */
+    results?: MemorySearchItem[];
+}
+export declare function memorySearchToolCallItemParamSerializer(item: MemorySearchToolCallItemParam): any;
+export declare function memorySearchItemArraySerializer(result: Array<MemorySearchItem>): any[];
+export declare function memorySearchItemArrayDeserializer(result: Array<MemorySearchItem>): any[];
+/** A retrieved memory item from memory search. */
+export interface MemorySearchItem {
+    /** Retrieved memory item. */
+    memory_item: MemoryItemUnion;
+}
+export declare function memorySearchItemSerializer(item: MemorySearchItem): any;
+export declare function memorySearchItemDeserializer(item: any): MemorySearchItem;
+/** A single memory item stored in the memory store, containing content and metadata. */
+export interface MemoryItem {
+    /** The unique ID of the memory item. */
+    memory_id: string;
+    /** The last update time of the memory item. */
+    updated_at: Date;
+    /** The namespace that logically groups and isolates memories, such as a user ID. */
+    scope: string;
+    /** The content of the memory. */
+    content: string;
+    /** The kind of the memory item. */
+    /** The discriminator possible values: user_profile, chat_summary */
+    kind: MemoryItemKind;
+}
+export declare function memoryItemSerializer(item: MemoryItem): any;
+export declare function memoryItemDeserializer(item: any): MemoryItem;
+/** Alias for MemoryItemUnion */
+export type MemoryItemUnion = UserProfileMemoryItem | ChatSummaryMemoryItem | MemoryItem;
+export declare function memoryItemUnionSerializer(item: MemoryItemUnion): any;
+export declare function memoryItemUnionDeserializer(item: any): MemoryItemUnion;
+/** Memory item kind. */
+export type MemoryItemKind = "user_profile" | "chat_summary";
+/** A memory item specifically containing user profile information extracted from conversations, such as preferences, interests, and personal details. */
+export interface UserProfileMemoryItem extends MemoryItem {
+    /** The kind of the memory item. */
+    kind: "user_profile";
+}
+export declare function userProfileMemoryItemSerializer(item: UserProfileMemoryItem): any;
+export declare function userProfileMemoryItemDeserializer(item: any): UserProfileMemoryItem;
+/** A memory item containing a summary extracted from conversations. */
+export interface ChatSummaryMemoryItem extends MemoryItem {
+    /** The kind of the memory item. */
+    kind: "chat_summary";
+}
+export declare function chatSummaryMemoryItemSerializer(item: ChatSummaryMemoryItem): any;
+export declare function chatSummaryMemoryItemDeserializer(item: any): ChatSummaryMemoryItem;
+export declare function itemParamUnionArraySerializer(result: Array<ItemParamUnion>): any[];
+/** Memory search response. */
+export interface MemoryStoreSearchResponse {
+    /** The unique ID of this search request. Use this value as previous_search_id in subsequent requests to perform incremental searches. */
+    search_id: string;
+    /** Related memory items found during the search operation. */
+    memories: MemorySearchItem[];
+    /** Usage statistics associated with the memory search operation. */
+    usage: MemoryStoreOperationUsage;
+}
+export declare function memoryStoreSearchResponseDeserializer(item: any): MemoryStoreSearchResponse;
+/** Usage statistics of a memory store operation. */
+export interface MemoryStoreOperationUsage {
+    /** The number of embedding tokens. */
+    embedding_tokens: number;
+    /** The number of input tokens. */
+    input_tokens: number;
+    /** A detailed breakdown of the input tokens. */
+    input_tokens_details: {
+        cached_tokens: number;
+    };
+    /** The number of output tokens. */
+    output_tokens: number;
+    /** A detailed breakdown of the output tokens. */
+    output_tokens_details: {
+        reasoning_tokens: number;
+    };
+    /** The total number of tokens used. */
+    total_tokens: number;
+}
+export declare function memoryStoreOperationUsageDeserializer(item: any): MemoryStoreOperationUsage;
+/** model interface _MemoryStoreOperationUsageInputTokensDetails */
+export interface _MemoryStoreOperationUsageInputTokensDetails {
+    /**
+     * The number of tokens that were retrieved from the cache.
+     * [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
+     */
+    cached_tokens: number;
+}
+export declare function _memoryStoreOperationUsageInputTokensDetailsDeserializer(item: any): _MemoryStoreOperationUsageInputTokensDetails;
+/** model interface _MemoryStoreOperationUsageOutputTokensDetails */
+export interface _MemoryStoreOperationUsageOutputTokensDetails {
+    /** The number of reasoning tokens. */
+    reasoning_tokens: number;
+}
+export declare function _memoryStoreOperationUsageOutputTokensDetailsDeserializer(item: any): _MemoryStoreOperationUsageOutputTokensDetails;
+/** Provides the status of a memory store update operation. */
+export interface MemoryStoreUpdateResponse {
+    /** The unique ID of this update request. Use this value as previous_update_id in subsequent requests to perform incremental updates. */
+    update_id: string;
+    /** The status of the memory update operation. One of "queued", "in_progress", "completed", "failed", or "superseded". */
+    status: MemoryStoreUpdateStatus;
+    /** The update_id the operation was superseded by when status is "superseded". */
+    superseded_by?: string;
+    /** The result of memory store update operation when status is "completed". */
+    result?: MemoryStoreUpdateResult;
+    /** Error object that describes the error when status is "failed". */
+    error?: ApiError;
+}
+export declare function memoryStoreUpdateResponseDeserializer(item: any): MemoryStoreUpdateResponse;
+/** Status of a memory store update operation. */
+export type MemoryStoreUpdateStatus = "queued" | "in_progress" | "completed" | "failed" | "superseded";
+/** Memory update result. */
+export interface MemoryStoreUpdateResult {
+    /** A list of individual memory operations that were performed during the update. */
+    memory_operations: MemoryOperation[];
+    /** Usage statistics associated with the memory update operation. */
+    usage: MemoryStoreOperationUsage;
+}
+export declare function MemoryStoreUpdateResultDeserializer(item: any): MemoryStoreUpdateResult;
+export declare function memoryOperationArrayDeserializer(result: Array<MemoryOperation>): any[];
+/** Represents a single memory operation (create, update, or delete) performed on a memory item. */
+export interface MemoryOperation {
+    /** The type of memory operation being performed. */
+    kind: MemoryOperationKind;
+    /** The memory item to create, update, or delete. */
+    memory_item: MemoryItemUnion;
+}
+export declare function memoryOperationDeserializer(item: any): MemoryOperation;
+/** Memory operation kind. */
+export type MemoryOperationKind = "create" | "update" | "delete";
+/** Response for deleting memories from a scope. */
+export interface MemoryStoreDeleteScopeResponse {
+    /** The object type. Always 'memory_store.scope.deleted'. */
+    object: "memory_store.scope.deleted";
+    /** The name of the memory store. */
+    name: string;
+    /** The scope from which memories were deleted. */
+    scope: string;
+    /** Whether the deletion operation was successful. */
+    deleted: boolean;
+}
+export declare function memoryStoreDeleteScopeResponseDeserializer(item: any): MemoryStoreDeleteScopeResponse;
 /** Response from the list and get connections operations */
 export interface Connection {
     /** The friendly name of the connection, provided by the user. */
@@ -15,27 +2180,27 @@ export interface Connection {
     /** Metadata of the connection */
     readonly metadata: Record<string, string>;
 }
+export declare function connectionDeserializer(item: any): Connection;
 /** The Type (or category) of the connection */
-export type ConnectionType = "AzureOpenAI" | "AzureBlob" | "AzureStorageAccount" | "CognitiveSearch" | "CosmosDB" | "ApiKey" | "AppConfig" | "AppInsights" | "CustomKeys";
+export type ConnectionType = "AzureOpenAI" | "AzureBlob" | "AzureStorageAccount" | "CognitiveSearch" | "CosmosDB" | "ApiKey" | "AppConfig" | "AppInsights" | "CustomKeys" | "RemoteTool";
 /** A base class for connection credentials */
 export interface BaseCredentials {
     /** The type of credential used by the connection */
-    /** The discriminator possible values: ApiKey, AAD, CustomKeys, SAS, None */
+    /** The discriminator possible values: ApiKey, AAD, CustomKeys, SAS, None, AgenticIdentityToken */
     readonly type: CredentialType;
 }
-export declare function connectionDeserializer(item: any): Connection;
 export declare function baseCredentialsDeserializer(item: any): BaseCredentials;
 /** Alias for BaseCredentialsUnion */
-export type BaseCredentialsUnion = ApiKeyCredentials | EntraIDCredentials | CustomCredential | SASCredentials | NoAuthenticationCredentials | BaseCredentials;
+export type BaseCredentialsUnion = ApiKeyCredentials | EntraIDCredentials | CustomCredential | SASTokenCredentials | NoAuthenticationCredentials | AgenticIdentityCredentials | BaseCredentials;
 export declare function baseCredentialsUnionDeserializer(item: any): BaseCredentialsUnion;
 /** The credential type used by the connection */
-export type CredentialType = "ApiKey" | "AAD" | "SAS" | "CustomKeys" | "None";
+export type CredentialType = "ApiKey" | "AAD" | "SAS" | "CustomKeys" | "None" | "AgenticIdentityToken";
 /** API Key Credential definition */
 export interface ApiKeyCredentials extends BaseCredentials {
     /** The credential type */
     readonly type: "ApiKey";
     /** API Key */
-    readonly apiKey?: string;
+    readonly apiKey: string;
 }
 export declare function apiKeyCredentialsDeserializer(item: any): ApiKeyCredentials;
 /** Entra ID credential definition */
@@ -48,24 +2213,30 @@ export declare function entraIDCredentialsDeserializer(item: any): EntraIDCreden
 export interface CustomCredential extends BaseCredentials {
     /** The credential type */
     readonly type: "CustomKeys";
-    /** The credential type */
-    readonly keys: Record<string, string>;
+    /** Additional properties */
+    additionalProperties?: Record<string, string>;
 }
 export declare function customCredentialDeserializer(item: any): CustomCredential;
 /** Shared Access Signature (SAS) credential definition */
-export interface SASCredentials extends BaseCredentials {
+export interface SASTokenCredentials extends BaseCredentials {
     /** The credential type */
     readonly type: "SAS";
     /** SAS token */
-    readonly sasToken?: string;
+    readonly sasToken: string;
 }
-export declare function sasCredentialsDeserializer(item: any): SASCredentials;
+export declare function sasCredentialsDeserializer(item: any): SASTokenCredentials;
 /** Credentials that do not require authentication */
 export interface NoAuthenticationCredentials extends BaseCredentials {
     /** The credential type */
     readonly type: "None";
 }
 export declare function noAuthenticationCredentialsDeserializer(item: any): NoAuthenticationCredentials;
+/** Agentic identity credential definition */
+export interface AgenticIdentityCredentials extends BaseCredentials {
+    /** The credential type */
+    readonly type: "AgenticIdentityToken";
+}
+export declare function agenticIdentityCredentialsDeserializer(item: any): AgenticIdentityCredentials;
 /** Paged collection of Connection items */
 export interface _PagedConnection {
     /** The Connection items on this page */
@@ -87,7 +2258,7 @@ export declare function datasetVersionUnionArraySerializer(result: Array<Dataset
 export declare function datasetVersionUnionArrayDeserializer(result: Array<DatasetVersionUnion>): any[];
 /** DatasetVersion Definition */
 export interface DatasetVersion {
-    /** URI of the data. Example: https://go.microsoft.com/fwlink/?linkid=2202330 */
+    /** URI of the data ([example](https://go.microsoft.com/fwlink/?linkid=2202330)) */
     dataUri: string;
     /** Dataset type */
     /** The discriminator possible values: uri_file, uri_folder */
@@ -153,7 +2324,7 @@ export interface PendingUploadResponse {
 export declare function pendingUploadResponseDeserializer(item: any): PendingUploadResponse;
 /** Blob reference details. */
 export interface BlobReference {
-    /** Blob URI path for client to upload data. Example: https://blob.windows.core.net/Container/Path */
+    /** Blob URI path for client to upload data. Example: `https://blob.windows.core.net/Container/Path` */
     blobUri: string;
     /** ARM ID of the storage account to use. */
     storageAccountArmId: string;
@@ -168,13 +2339,13 @@ export interface SasCredential {
     /** Type of credential */
     readonly type: "SAS";
 }
-export declare function sasCredentialDeserializer(item: any): SasCredential;
+export declare function SasCredentialDeserializer(item: any): SasCredential;
 /** Represents a reference to a blob for consumption */
-export interface AssetCredentialResponse {
+export interface DatasetCredential {
     /** Credential info to access the storage account. */
     blobReference: BlobReference;
 }
-export declare function assetCredentialResponseDeserializer(item: any): AssetCredentialResponse;
+export declare function datasetCredentialDeserializer(item: any): DatasetCredential;
 /** Paged collection of Index items */
 export interface _PagedIndex {
     /** The Index items on this page */
@@ -301,13 +2472,13 @@ export interface ModelDeployment extends Deployment {
     /** Capabilities of deployed model */
     readonly capabilities: Record<string, string>;
     /** Sku of the model deployment */
-    readonly sku: Sku;
+    readonly sku: ModelDeploymentSku;
     /** Name of the connection the deployment comes from */
     readonly connectionName?: string;
 }
 export declare function modelDeploymentDeserializer(item: any): ModelDeployment;
 /** Sku information */
-export interface Sku {
+export interface ModelDeploymentSku {
     /** Sku capacity */
     capacity: number;
     /** Sku family */
@@ -319,7 +2490,7 @@ export interface Sku {
     /** Sku tier */
     tier: string;
 }
-export declare function skuDeserializer(item: any): Sku;
+export declare function modelDeploymentSkuDeserializer(item: any): ModelDeploymentSku;
 /** Paged collection of Deployment items */
 export interface _PagedDeployment {
     /** The Deployment items on this page */
@@ -329,13 +2500,899 @@ export interface _PagedDeployment {
 }
 export declare function _pagedDeploymentDeserializer(item: any): _PagedDeployment;
 export declare function deploymentUnionArrayDeserializer(result: Array<DeploymentUnion>): any[];
+/** Red team details. */
+export interface RedTeam {
+    /** Identifier of the red team run. */
+    readonly name: string;
+    /** Name of the red-team run. */
+    displayName?: string;
+    /** Number of simulation rounds. */
+    numTurns?: number;
+    /** List of attack strategies or nested lists of attack strategies. */
+    attackStrategies?: AttackStrategy[];
+    /** Simulation-only or Simulation + Evaluation. Default false, if true the scan outputs conversation not evaluation result. */
+    simulationOnly?: boolean;
+    /** List of risk categories to generate attack objectives for. */
+    riskCategories?: RiskCategory[];
+    /** Application scenario for the red team operation, to generate scenario specific attacks. */
+    applicationScenario?: string;
+    /** Red team's tags. Unlike properties, tags are fully mutable. */
+    tags?: Record<string, string>;
+    /** Red team's properties. Unlike tags, properties are add-only. Once added, a property cannot be removed. */
+    properties?: Record<string, string>;
+    /** Status of the red-team. It is set by service and is read-only. */
+    readonly status?: string;
+    /** Target configuration for the red-team run. */
+    target: TargetConfigUnion;
+}
+export declare function redTeamSerializer(item: RedTeam): any;
+export declare function redTeamDeserializer(item: any): RedTeam;
+/** Strategies for attacks. */
+export type AttackStrategy = "easy" | "moderate" | "difficult" | "ascii_art" | "ascii_smuggler" | "atbash" | "base64" | "binary" | "caesar" | "character_space" | "jailbreak" | "ansii_attack" | "character_swap" | "suffix_append" | "string_join" | "unicode_confusable" | "unicode_substitution" | "diacritic" | "flip" | "leetspeak" | "rot13" | "morse" | "url" | "baseline" | "indirect_jailbreak" | "tense" | "multi_turn" | "crescendo";
+/** Risk category for the attack objective. */
+export type RiskCategory = "HateUnfairness" | "Violence" | "Sexual" | "SelfHarm" | "ProtectedMaterial" | "CodeVulnerability" | "UngroundedAttributes" | "ProhibitedActions" | "SensitiveDataLeakage" | "TaskAdherence";
+/** Abstract class for target configuration. */
+export interface TargetConfig {
+    /** Type of the model configuration. */
+    /** The discriminator possible values: AzureOpenAIModel */
+    type: string;
+}
+export declare function targetConfigSerializer(item: TargetConfig): any;
+export declare function targetConfigDeserializer(item: any): TargetConfig;
+/** Alias for TargetConfigUnion */
+export type TargetConfigUnion = AzureOpenAIModelConfiguration | TargetConfig;
+export declare function targetConfigUnionSerializer(item: TargetConfigUnion): any;
+export declare function targetConfigUnionDeserializer(item: any): TargetConfigUnion;
+/** Azure OpenAI model configuration. The API version would be selected by the service for querying the model. */
+export interface AzureOpenAIModelConfiguration extends TargetConfig {
+    type: "AzureOpenAIModel";
+    /** Deployment name for AOAI model. Example: gpt-4o if in AIServices or connection based `connection_name/deployment_name` (e.g. `my-aoai-connection/gpt-4o`). */
+    modelDeploymentName: string;
+}
+export declare function azureOpenAIModelConfigurationSerializer(item: AzureOpenAIModelConfiguration): any;
+export declare function azureOpenAIModelConfigurationDeserializer(item: any): AzureOpenAIModelConfiguration;
+/** Paged collection of RedTeam items */
+export interface _PagedRedTeam {
+    /** The RedTeam items on this page */
+    value: RedTeam[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedRedTeamDeserializer(item: any): _PagedRedTeam;
+export declare function redTeamArraySerializer(result: Array<RedTeam>): any[];
+export declare function redTeamArrayDeserializer(result: Array<RedTeam>): any[];
+/** Evaluation rule model. */
+export interface EvaluationRule {
+    /** Unique identifier for the evaluation rule. */
+    readonly id: string;
+    /** Display Name for the evaluation rule. */
+    displayName?: string;
+    /** Description for the evaluation rule. */
+    description?: string;
+    /** Definition of the evaluation rule action. */
+    action: EvaluationRuleActionUnion;
+    /** Filter condition of the evaluation rule. */
+    filter?: EvaluationRuleFilter;
+    /** Event type that the evaluation rule applies to. */
+    eventType: EvaluationRuleEventType;
+    /** Indicates whether the evaluation rule is enabled. Default is true. */
+    enabled: boolean;
+    /** System metadata for the evaluation rule. */
+    readonly systemData: Record<string, string>;
+}
+export declare function evaluationRuleSerializer(item: EvaluationRule): any;
+export declare function evaluationRuleDeserializer(item: any): EvaluationRule;
+/** Evaluation action model. */
+export interface EvaluationRuleAction {
+    /** Type of the evaluation action. */
+    /** The discriminator possible values: continuousEvaluation, humanEvaluation */
+    type: EvaluationRuleActionType;
+}
+export declare function evaluationRuleActionSerializer(item: EvaluationRuleAction): any;
+export declare function evaluationRuleActionDeserializer(item: any): EvaluationRuleAction;
+/** Alias for EvaluationRuleActionUnion */
+export type EvaluationRuleActionUnion = ContinuousEvaluationRuleAction | HumanEvaluationRuleAction | EvaluationRuleAction;
+export declare function evaluationRuleActionUnionSerializer(item: EvaluationRuleActionUnion): any;
+export declare function evaluationRuleActionUnionDeserializer(item: any): EvaluationRuleActionUnion;
+/** Type of the evaluation action. */
+export type EvaluationRuleActionType = "continuousEvaluation" | "humanEvaluation";
+/** Evaluation rule action for continuous evaluation. */
+export interface ContinuousEvaluationRuleAction extends EvaluationRuleAction {
+    type: "continuousEvaluation";
+    /** Eval Id to add continuous evaluation runs to. */
+    evalId: string;
+    /** Maximum number of evaluation runs allowed per hour. */
+    maxHourlyRuns?: number;
+}
+export declare function continuousEvaluationRuleActionSerializer(item: ContinuousEvaluationRuleAction): any;
+export declare function continuousEvaluationRuleActionDeserializer(item: any): ContinuousEvaluationRuleAction;
+/** Evaluation rule action for human evaluation. */
+export interface HumanEvaluationRuleAction extends EvaluationRuleAction {
+    type: "humanEvaluation";
+    /** Human evaluation template Id. */
+    templateId: string;
+}
+export declare function humanEvaluationRuleActionSerializer(item: HumanEvaluationRuleAction): any;
+export declare function humanEvaluationRuleActionDeserializer(item: any): HumanEvaluationRuleAction;
+/** Evaluation filter model. */
+export interface EvaluationRuleFilter {
+    /** Filter by agent name. */
+    agentName: string;
+}
+export declare function evaluationRuleFilterSerializer(item: EvaluationRuleFilter): any;
+export declare function evaluationRuleFilterDeserializer(item: any): EvaluationRuleFilter;
+/** Type of the evaluation rule event. */
+export type EvaluationRuleEventType = "responseCompleted" | "manual";
+/** Paged collection of EvaluationRule items */
+export interface _PagedEvaluationRule {
+    /** The EvaluationRule items on this page */
+    value: EvaluationRule[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedEvaluationRuleDeserializer(item: any): _PagedEvaluationRule;
+export declare function evaluationRuleArraySerializer(result: Array<EvaluationRule>): any[];
+export declare function evaluationRuleArrayDeserializer(result: Array<EvaluationRule>): any[];
+/** Evaluation Taxonomy Definition */
+export interface EvaluationTaxonomy {
+    /** Asset ID, a unique identifier for the asset */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name: string;
+    /** The version of the resource */
+    readonly version: string;
+    /** The asset description text. */
+    description?: string;
+    /** Tag dictionary. Tags can be added, removed, and updated. */
+    tags?: Record<string, string>;
+    /** Input configuration for the evaluation taxonomy. */
+    taxonomyInput: EvaluationTaxonomyInputUnion;
+    /** List of taxonomy categories. */
+    taxonomyCategories?: TaxonomyCategory[];
+    /** Additional properties for the evaluation taxonomy. */
+    properties?: Record<string, string>;
+}
+export declare function evaluationTaxonomySerializer(item: EvaluationTaxonomy): any;
+export declare function evaluationTaxonomyDeserializer(item: any): EvaluationTaxonomy;
+/** Input configuration for the evaluation taxonomy. */
+export interface EvaluationTaxonomyInput {
+    /** Input type of the evaluation taxonomy. */
+    /** The discriminator possible values: agent */
+    type: EvaluationTaxonomyInputType;
+}
+export declare function evaluationTaxonomyInputSerializer(item: EvaluationTaxonomyInput): any;
+export declare function evaluationTaxonomyInputDeserializer(item: any): EvaluationTaxonomyInput;
+/** Alias for EvaluationTaxonomyInputUnion */
+export type EvaluationTaxonomyInputUnion = AgentTaxonomyInput | EvaluationTaxonomyInput;
+export declare function evaluationTaxonomyInputUnionSerializer(item: EvaluationTaxonomyInputUnion): any;
+export declare function evaluationTaxonomyInputUnionDeserializer(item: any): EvaluationTaxonomyInputUnion;
+/** Type of the evaluation taxonomy input. */
+export type EvaluationTaxonomyInputType = "agent" | "policy";
+/** Input configuration for the evaluation taxonomy when the input type is agent. */
+export interface AgentTaxonomyInput extends EvaluationTaxonomyInput {
+    /** Input type of the evaluation taxonomy. */
+    type: "agent";
+    /** Target configuration for the agent. */
+    target: AzureAIAgentTarget;
+    /** List of risk categories to evaluate against. */
+    riskCategories: RiskCategory[];
+}
+export declare function agentTaxonomyInputSerializer(item: AgentTaxonomyInput): any;
+export declare function agentTaxonomyInputDeserializer(item: any): AgentTaxonomyInput;
+/** Represents a target specifying an Azure AI agent. */
+export interface AzureAIAgentTarget extends Target {
+    /** The type of target, always `azure_ai_agent`. */
+    type: "azure_ai_agent";
+    /** The unique identifier of the Azure AI agent. */
+    name: string;
+    /** The version of the Azure AI agent. */
+    version?: string;
+    /** The parameters used to control the sampling behavior of the agent during text generation. */
+    tool_descriptions?: ToolDescription[];
+}
+export declare function azureAIAgentTargetSerializer(item: AzureAIAgentTarget): any;
+export declare function azureAIAgentTargetDeserializer(item: any): AzureAIAgentTarget;
+export declare function toolDescriptionArraySerializer(result: Array<ToolDescription>): any[];
+export declare function toolDescriptionArrayDeserializer(result: Array<ToolDescription>): any[];
+/** Description of a tool that can be used by an agent. */
+export interface ToolDescription {
+    /** The name of the tool. */
+    name?: string;
+    /** A brief description of the tool's purpose. */
+    description?: string;
+}
+export declare function toolDescriptionSerializer(item: ToolDescription): any;
+export declare function toolDescriptionDeserializer(item: any): ToolDescription;
+export declare function taxonomyCategoryArraySerializer(result: Array<TaxonomyCategory>): any[];
+export declare function taxonomyCategoryArrayDeserializer(result: Array<TaxonomyCategory>): any[];
+/** Taxonomy category definition. */
+export interface TaxonomyCategory {
+    /** Unique identifier of the taxonomy category. */
+    id: string;
+    /** Name of the taxonomy category. */
+    name: string;
+    /** Description of the taxonomy category. */
+    description?: string;
+    /** Risk category associated with this taxonomy category. */
+    riskCategory: RiskCategory;
+    /** List of taxonomy sub categories. */
+    subCategories: TaxonomySubCategory[];
+    /** Additional properties for the taxonomy category. */
+    properties?: Record<string, string>;
+}
+export declare function taxonomyCategorySerializer(item: TaxonomyCategory): any;
+export declare function taxonomyCategoryDeserializer(item: any): TaxonomyCategory;
+export declare function taxonomySubCategoryArraySerializer(result: Array<TaxonomySubCategory>): any[];
+export declare function taxonomySubCategoryArrayDeserializer(result: Array<TaxonomySubCategory>): any[];
+/** Taxonomy sub-category definition. */
+export interface TaxonomySubCategory {
+    /** Unique identifier of the taxonomy sub-category. */
+    id: string;
+    /** Name of the taxonomy sub-category. */
+    name: string;
+    /** Description of the taxonomy sub-category. */
+    description?: string;
+    /** List of taxonomy items under this sub-category. */
+    enabled: boolean;
+    /** Additional properties for the taxonomy sub-category. */
+    properties?: Record<string, string>;
+}
+export declare function taxonomySubCategorySerializer(item: TaxonomySubCategory): any;
+export declare function taxonomySubCategoryDeserializer(item: any): TaxonomySubCategory;
+/** Base class for targets with discriminator support. */
+export interface Target {
+    /** The type of target. */
+    /** The discriminator possible values: azure_ai_model, azure_ai_agent, azure_ai_assistant */
+    type: string;
+}
+export declare function targetSerializer(item: Target): any;
+export declare function targetDeserializer(item: any): Target;
+/** Alias for TargetUnion */
+export type TargetUnion = AzureAIAgentTarget | Target;
+export declare function targetUnionSerializer(item: TargetUnion): any;
+export declare function targetUnionDeserializer(item: any): TargetUnion;
+/** Paged collection of EvaluationTaxonomy items */
+export interface _PagedEvaluationTaxonomy {
+    /** The EvaluationTaxonomy items on this page */
+    value: EvaluationTaxonomy[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedEvaluationTaxonomyDeserializer(item: any): _PagedEvaluationTaxonomy;
+export declare function evaluationTaxonomyArraySerializer(result: Array<EvaluationTaxonomy>): any[];
+export declare function evaluationTaxonomyArrayDeserializer(result: Array<EvaluationTaxonomy>): any[];
+/** Paged collection of EvaluatorVersion items */
+export interface _PagedEvaluatorVersion {
+    /** The EvaluatorVersion items on this page */
+    value: EvaluatorVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedEvaluatorVersionDeserializer(item: any): _PagedEvaluatorVersion;
+export declare function evaluatorVersionArraySerializer(result: Array<EvaluatorVersion>): any[];
+export declare function evaluatorVersionArrayDeserializer(result: Array<EvaluatorVersion>): any[];
+/** Evaluator Definition */
+export interface EvaluatorVersion {
+    /** Display Name for evaluator. It helps to find the evaluator easily in Microsoft Foundry. It does not need to be unique. */
+    display_name?: string;
+    /** Metadata about the evaluator */
+    metadata?: Record<string, string>;
+    /** The type of the evaluator */
+    evaluator_type: EvaluatorType;
+    /** The categories of the evaluator */
+    categories: EvaluatorCategory[];
+    /** Definition of the evaluator */
+    definition: EvaluatorDefinitionUnion;
+    /** Creator of the evaluator */
+    readonly created_by: string;
+    /** Creation date/time of the evaluator */
+    readonly created_at: number;
+    /** Last modified date/time of the evaluator */
+    readonly modified_at: number;
+    /** Asset ID, a unique identifier for the asset */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name: string;
+    /** The version of the resource */
+    readonly version: string;
+    /** The asset description text. */
+    description?: string;
+    /** Tag dictionary. Tags can be added, removed, and updated. */
+    tags?: Record<string, string>;
+}
+export declare function evaluatorVersionSerializer(item: EvaluatorVersion): any;
+export declare function evaluatorVersionDeserializer(item: any): EvaluatorVersion;
+/** The type of the evaluator */
+export type EvaluatorType = "builtin" | "custom";
+/** The category of the evaluator */
+export type EvaluatorCategory = "quality" | "safety" | "agents";
+/** Base evaluator configuration with discriminator */
+export interface EvaluatorDefinition {
+    /** The type of evaluator definition */
+    /** The discriminator possible values: code, prompt */
+    type: EvaluatorDefinitionType;
+    /** The JSON schema (Draft 2020-12) for the evaluator's input parameters. This includes parameters like type, properties, required. */
+    init_parameters?: unknown;
+    /** The JSON schema (Draft 2020-12) for the evaluator's input data. This includes parameters like type, properties, required. */
+    data_schema?: unknown;
+    /** List of output metrics produced by this evaluator */
+    metrics?: Record<string, EvaluatorMetric>;
+}
+export declare function evaluatorDefinitionSerializer(item: EvaluatorDefinition): any;
+export declare function evaluatorDefinitionDeserializer(item: any): EvaluatorDefinition;
+/** Alias for EvaluatorDefinitionUnion */
+export type EvaluatorDefinitionUnion = CodeBasedEvaluatorDefinition | PromptBasedEvaluatorDefinition | EvaluatorDefinition;
+export declare function evaluatorDefinitionUnionSerializer(item: EvaluatorDefinitionUnion): any;
+export declare function evaluatorDefinitionUnionDeserializer(item: any): EvaluatorDefinitionUnion;
+/** The type of evaluator definition */
+export type EvaluatorDefinitionType = "prompt" | "code" | "prompt_and_code" | "service" | "openai_graders";
+export declare function evaluatorMetricRecordSerializer(item: Record<string, EvaluatorMetric>): Record<string, any>;
+export declare function evaluatorMetricRecordDeserializer(item: Record<string, any>): Record<string, EvaluatorMetric>;
+/** Evaluator Metric */
+export interface EvaluatorMetric {
+    /** Type of the metric. */
+    type?: EvaluatorMetricType;
+    /** It indicates whether a higher value is better or a lower value is better for this metric. */
+    desirable_direction?: EvaluatorMetricDirection;
+    /** Minimum value for the metric */
+    min_value?: number;
+    /** Maximum value for the metric. If not specified, it is assumed to be unbounded. */
+    max_value?: number;
+    /** Indicates if this metric is primary when there are multiple metrics. */
+    is_primary?: boolean;
+}
+export declare function evaluatorMetricSerializer(item: EvaluatorMetric): any;
+export declare function evaluatorMetricDeserializer(item: any): EvaluatorMetric;
+/** The type of the evaluator */
+export type EvaluatorMetricType = "ordinal" | "continuous" | "boolean";
+/** The direction of the metric indicating whether a higher value is better, a lower value is better, or neutral */
+export type EvaluatorMetricDirection = "increase" | "decrease" | "neutral";
+/** Code-based evaluator definition using python code */
+export interface CodeBasedEvaluatorDefinition extends EvaluatorDefinition {
+    type: "code";
+    /** Inline code text for the evaluator */
+    code_text: string;
+}
+export declare function codeBasedEvaluatorDefinitionSerializer(item: CodeBasedEvaluatorDefinition): any;
+export declare function codeBasedEvaluatorDefinitionDeserializer(item: any): CodeBasedEvaluatorDefinition;
+/** Prompt-based evaluator */
+export interface PromptBasedEvaluatorDefinition extends EvaluatorDefinition {
+    type: "prompt";
+    /** The prompt text used for evaluation */
+    prompt_text: string;
+}
+export declare function promptBasedEvaluatorDefinitionSerializer(item: PromptBasedEvaluatorDefinition): any;
+export declare function promptBasedEvaluatorDefinitionDeserializer(item: any): PromptBasedEvaluatorDefinition;
+/** The response body for cluster insights. */
+export interface Insight {
+    /** The unique identifier for the insights report. */
+    readonly id: string;
+    /** Metadata about the insights report. */
+    readonly metadata: InsightsMetadata;
+    /** The current state of the insights. */
+    readonly state: OperationState;
+    /** User friendly display name for the insight. */
+    displayName: string;
+    /** Request for the insights analysis. */
+    request: InsightRequestUnion;
+    /** The result of the insights report. */
+    readonly result?: InsightResultUnion;
+}
+export declare function insightSerializer(item: Insight): any;
+export declare function insightDeserializer(item: any): Insight;
+/** Metadata about the insights. */
+export interface InsightsMetadata {
+    /** The timestamp when the insights were created. */
+    createdAt: Date;
+    /** The timestamp when the insights were completed. */
+    completedAt?: Date;
+}
+export declare function insightsMetadataDeserializer(item: any): InsightsMetadata;
+/** Enum describing allowed operation states. */
+export type OperationState = "NotStarted" | "Running" | "Succeeded" | "Failed" | "Canceled";
+/** The request of the insights report. */
+export interface InsightRequest {
+    /** The type of request. */
+    /** The discriminator possible values: EvaluationRunClusterInsight, AgentClusterInsight, EvaluationComparison */
+    type: InsightType;
+}
+export declare function insightRequestSerializer(item: InsightRequest): any;
+export declare function insightRequestDeserializer(item: any): InsightRequest;
+/** Alias for InsightRequestUnion */
+export type InsightRequestUnion = EvaluationRunClusterInsightsRequest | AgentClusterInsightsRequest | EvaluationComparisonRequest | InsightRequest;
+export declare function insightRequestUnionSerializer(item: InsightRequestUnion): any;
+export declare function insightRequestUnionDeserializer(item: any): InsightRequestUnion;
+/** The request of the insights. */
+export type InsightType = "EvaluationRunClusterInsight" | "AgentClusterInsight" | "EvaluationComparison";
+/** Insights on set of Evaluation Results */
+export interface EvaluationRunClusterInsightsRequest extends InsightRequest {
+    /** The type of insights request. */
+    type: "EvaluationRunClusterInsight";
+    /** Evaluation Id for the insights. */
+    evalId: string;
+    /** List of evaluation run IDs for the insights. */
+    runIds: string[];
+    /** Configuration of the model used in the insight generation. */
+    modelConfiguration?: InsightModelConfiguration;
+}
+export declare function evaluationRunClusterInsightsRequestSerializer(item: EvaluationRunClusterInsightsRequest): any;
+export declare function evaluationRunClusterInsightsRequestDeserializer(item: any): EvaluationRunClusterInsightsRequest;
+/** Configuration of the model used in the insight generation. */
+export interface InsightModelConfiguration {
+    /** The model deployment to be evaluated. Accepts either the deployment name alone or with the connection name as '{connectionName}/<modelDeploymentName>'. */
+    modelDeploymentName: string;
+}
+export declare function insightModelConfigurationSerializer(item: InsightModelConfiguration): any;
+export declare function insightModelConfigurationDeserializer(item: any): InsightModelConfiguration;
+/** Insights on set of Agent Evaluation Results */
+export interface AgentClusterInsightsRequest extends InsightRequest {
+    /** The type of request. */
+    type: "AgentClusterInsight";
+    /** Identifier for the agent. */
+    agentName: string;
+    /** Configuration of the model used in the insight generation. */
+    modelConfiguration?: InsightModelConfiguration;
+}
+export declare function agentClusterInsightsRequestSerializer(item: AgentClusterInsightsRequest): any;
+export declare function agentClusterInsightsRequestDeserializer(item: any): AgentClusterInsightsRequest;
+/** Evaluation Comparison Request */
+export interface EvaluationComparisonRequest extends InsightRequest {
+    /** The type of request. */
+    type: "EvaluationComparison";
+    /** Identifier for the evaluation. */
+    evalId: string;
+    /** The baseline run ID for comparison. */
+    baselineRunId: string;
+    /** List of treatment run IDs for comparison. */
+    treatmentRunIds: string[];
+}
+export declare function evaluationComparisonRequestSerializer(item: EvaluationComparisonRequest): any;
+export declare function evaluationComparisonRequestDeserializer(item: any): EvaluationComparisonRequest;
+/** The result of the insights. */
+export interface InsightResult {
+    /** The type of insights result. */
+    /** The discriminator possible values: EvaluationComparison, EvaluationRunClusterInsight, AgentClusterInsight */
+    type: InsightType;
+}
+export declare function insightResultDeserializer(item: any): InsightResult;
+/** Alias for InsightResultUnion */
+export type InsightResultUnion = EvalCompareReport | EvaluationRunClusterInsightResult | AgentClusterInsightResult | InsightResult;
+export declare function insightResultUnionDeserializer(item: any): InsightResultUnion;
+/** Insights from the evaluation comparison. */
+export interface EvalCompareReport extends InsightResult {
+    /** The type of insights result. */
+    type: "EvaluationComparison";
+    /** Comparison results for each treatment run against the baseline. */
+    comparisons: EvalRunResultComparison[];
+    /** The statistical method used for comparison. */
+    method: string;
+}
+export declare function evalCompareReportDeserializer(item: any): EvalCompareReport;
+export declare function evalRunResultComparisonArrayDeserializer(result: Array<EvalRunResultComparison>): any[];
+/** Comparison results for treatment runs against the baseline. */
+export interface EvalRunResultComparison {
+    /** Name of the testing criteria. */
+    testingCriteria: string;
+    /** Metric being evaluated. */
+    metric: string;
+    /** Name of the evaluator for this testing criteria. */
+    evaluator: string;
+    /** Summary statistics of the baseline run. */
+    baselineRunSummary: EvalRunResultSummary;
+    /** List of comparison results for each treatment run. */
+    compareItems: EvalRunResultCompareItem[];
+}
+export declare function evalRunResultComparisonDeserializer(item: any): EvalRunResultComparison;
+/** Summary statistics of a metric in an evaluation run. */
+export interface EvalRunResultSummary {
+    /** The evaluation run ID. */
+    runId: string;
+    /** Number of samples in the evaluation run. */
+    sampleCount: number;
+    /** Average value of the metric in the evaluation run. */
+    average: number;
+    /** Standard deviation of the metric in the evaluation run. */
+    standardDeviation: number;
+}
+export declare function evalRunResultSummaryDeserializer(item: any): EvalRunResultSummary;
+export declare function evalRunResultCompareItemArrayDeserializer(result: Array<EvalRunResultCompareItem>): any[];
+/** Metric comparison for a treatment against the baseline. */
+export interface EvalRunResultCompareItem {
+    /** The treatment run ID. */
+    treatmentRunId: string;
+    /** Summary statistics of the treatment run. */
+    treatmentRunSummary: EvalRunResultSummary;
+    /** Estimated difference between treatment and baseline. */
+    deltaEstimate: number;
+    /** P-value for the treatment effect. */
+    pValue: number;
+    /** Type of treatment effect. */
+    treatmentEffect: TreatmentEffectType;
+}
+export declare function evalRunResultCompareItemDeserializer(item: any): EvalRunResultCompareItem;
+/** Treatment Effect Type. */
+export type TreatmentEffectType = "TooFewSamples" | "Inconclusive" | "Changed" | "Improved" | "Degraded";
+/** Insights from the evaluation run cluster analysis. */
+export interface EvaluationRunClusterInsightResult extends InsightResult {
+    /** The type of insights result. */
+    type: "EvaluationRunClusterInsight";
+    clusterInsight: ClusterInsightResult;
+}
+export declare function evaluationRunClusterInsightResultDeserializer(item: any): EvaluationRunClusterInsightResult;
+/** Insights from the cluster analysis. */
+export interface ClusterInsightResult {
+    /** Summary of the insights report. */
+    summary: InsightSummary;
+    /** List of clusters identified in the insights. */
+    clusters: InsightCluster[];
+    /**
+     *   Optional mapping of IDs to 2D coordinates used by the UX for visualization.
+     *
+     *   The map keys are string identifiers (for example, a cluster id or a sample id)
+     *   and the values are the coordinates and visual size for rendering on a 2D chart.
+     *
+     *   This property is omitted unless the client requests coordinates (for example,
+     *   by passing `includeCoordinates=true` as a query parameter).
+     *
+     *   Example:
+     *   ```
+     *   {
+     *     "cluster-1": { "x": 12, "y": 34, "size": 8 },
+     *     "sample-123": { "x": 18, "y": 22, "size": 4 }
+     *   }
+     *   ```
+     *
+     *   Coordinates are intended only for client-side visualization and do not
+     *   modify the canonical insights results.
+     */
+    coordinates?: Record<string, ChartCoordinate>;
+}
+export declare function clusterInsightResultDeserializer(item: any): ClusterInsightResult;
+/** Summary of the error cluster analysis. */
+export interface InsightSummary {
+    /** Total number of samples analyzed. */
+    sampleCount: number;
+    /** Total number of unique subcluster labels. */
+    uniqueSubclusterCount: number;
+    /** Total number of unique clusters. */
+    uniqueClusterCount: number;
+    /** Method used for clustering. */
+    method: string;
+    /** Token usage while performing clustering analysis */
+    usage: ClusterTokenUsage;
+}
+export declare function insightSummaryDeserializer(item: any): InsightSummary;
+/** Token usage for cluster analysis */
+export interface ClusterTokenUsage {
+    /** input token usage */
+    inputTokenUsage: number;
+    /** output token usage */
+    outputTokenUsage: number;
+    /** total token usage */
+    totalTokenUsage: number;
+}
+export declare function clusterTokenUsageDeserializer(item: any): ClusterTokenUsage;
+export declare function insightClusterArrayDeserializer(result: Array<InsightCluster>): any[];
+/** A cluster of analysis samples. */
+export interface InsightCluster {
+    /** The id of the analysis cluster. */
+    id: string;
+    /** Label for the cluster */
+    label: string;
+    /** Suggestion for the cluster */
+    suggestion: string;
+    /** The title of the suggestion for the cluster */
+    suggestionTitle: string;
+    /** Description of the analysis cluster. */
+    description: string;
+    /** The weight of the analysis cluster. This indicate number of samples in the cluster. */
+    weight: number;
+    /** List of subclusters within this cluster. Empty if no subclusters exist. */
+    subClusters?: InsightCluster[];
+    /** List of samples that belong to this cluster. Empty if samples are part of subclusters. */
+    samples?: InsightSampleUnion[];
+}
+export declare function insightClusterDeserializer(item: any): InsightCluster;
+export declare function insightSampleUnionArrayDeserializer(result: Array<InsightSampleUnion>): any[];
+/** A sample from the analysis. */
+export interface InsightSample {
+    /** The unique identifier for the analysis sample. */
+    id: string;
+    /** Sample type */
+    /** The discriminator possible values: EvaluationResultSample */
+    type: SampleType;
+    /** Features to help with additional filtering of data in UX. */
+    features: Record<string, any>;
+    /** Info about the correlation for the analysis sample. */
+    correlationInfo: Record<string, any>;
+}
+export declare function insightSampleDeserializer(item: any): InsightSample;
+/** Alias for InsightSampleUnion */
+export type InsightSampleUnion = EvaluationResultSample | InsightSample;
+export declare function insightSampleUnionDeserializer(item: any): InsightSampleUnion;
+/** The type of sample used in the analysis. */
+export type SampleType = "EvaluationResultSample";
+/** A sample from the evaluation result. */
+export interface EvaluationResultSample extends InsightSample {
+    /** Evaluation Result Sample Type */
+    type: "EvaluationResultSample";
+    /** Evaluation result for the analysis sample. */
+    evaluationResult: EvalResult;
+}
+export declare function evaluationResultSampleDeserializer(item: any): EvaluationResultSample;
+/** Result of the evaluation. */
+export interface EvalResult {
+    /** name of the check */
+    name: string;
+    /** type of the check */
+    type: string;
+    /** score */
+    score: number;
+    /** indicates if the check passed or failed */
+    passed: boolean;
+}
+export declare function evalResultDeserializer(item: any): EvalResult;
+export declare function chartCoordinateRecordDeserializer(item: Record<string, any>): Record<string, ChartCoordinate>;
+/** Coordinates for the analysis chart. */
+export interface ChartCoordinate {
+    /** X-axis coordinate. */
+    x: number;
+    /** Y-axis coordinate. */
+    y: number;
+    /** Size of the chart element. */
+    size: number;
+}
+export declare function chartCoordinateDeserializer(item: any): ChartCoordinate;
+/** Insights from the agent cluster analysis. */
+export interface AgentClusterInsightResult extends InsightResult {
+    /** The type of insights result. */
+    type: "AgentClusterInsight";
+    clusterInsight: ClusterInsightResult;
+}
+export declare function agentClusterInsightResultDeserializer(item: any): AgentClusterInsightResult;
+/** Paged collection of Insight items */
+export interface _PagedInsight {
+    /** The Insight items on this page */
+    value: Insight[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedInsightDeserializer(item: any): _PagedInsight;
+export declare function insightArraySerializer(result: Array<Insight>): any[];
+export declare function insightArrayDeserializer(result: Array<Insight>): any[];
+/** Schedule model. */
+export interface Schedule {
+    /** Identifier of the schedule. */
+    readonly id: string;
+    /** Name of the schedule. */
+    displayName?: string;
+    /** Description of the schedule. */
+    description?: string;
+    /** Enabled status of the schedule. */
+    enabled: boolean;
+    /** Provisioning status of the schedule. */
+    readonly provisioningStatus?: ScheduleProvisioningStatus;
+    /** Trigger for the schedule. */
+    trigger: TriggerUnion;
+    /** Task for the schedule. */
+    task: ScheduleTaskUnion;
+    /** Schedule's tags. Unlike properties, tags are fully mutable. */
+    tags?: Record<string, string>;
+    /** Schedule's properties. Unlike tags, properties are add-only. Once added, a property cannot be removed. */
+    properties?: Record<string, string>;
+    /** System metadata for the resource. */
+    readonly systemData: Record<string, string>;
+}
+export declare function scheduleSerializer(item: Schedule): any;
+export declare function scheduleDeserializer(item: any): Schedule;
+/** Schedule provisioning status. */
+export type ScheduleProvisioningStatus = "Creating" | "Updating" | "Deleting" | "Succeeded" | "Failed";
+/** Base model for Trigger of the schedule. */
+export interface Trigger {
+    /** Type of the trigger. */
+    /** The discriminator possible values: Cron, Recurrence, OneTime */
+    type: TriggerType;
+}
+export declare function triggerSerializer(item: Trigger): any;
+export declare function triggerDeserializer(item: any): Trigger;
+/** Alias for TriggerUnion */
+export type TriggerUnion = CronTrigger | RecurrenceTrigger | OneTimeTrigger | Trigger;
+export declare function triggerUnionSerializer(item: TriggerUnion): any;
+export declare function triggerUnionDeserializer(item: any): TriggerUnion;
+/** Type of the trigger. */
+export type TriggerType = "Cron" | "Recurrence" | "OneTime";
+/** Cron based trigger. */
+export interface CronTrigger extends Trigger {
+    type: "Cron";
+    /** Cron expression that defines the schedule frequency. */
+    expression: string;
+    /** Time zone for the cron schedule. */
+    timeZone?: string;
+    /** Start time for the cron schedule in ISO 8601 format. */
+    startTime?: string;
+    /** End time for the cron schedule in ISO 8601 format. */
+    endTime?: string;
+}
+export declare function cronTriggerSerializer(item: CronTrigger): any;
+export declare function cronTriggerDeserializer(item: any): CronTrigger;
+/** Recurrence based trigger. */
+export interface RecurrenceTrigger extends Trigger {
+    /** Type of the trigger. */
+    type: "Recurrence";
+    /** Start time for the recurrence schedule in ISO 8601 format. */
+    startTime?: string;
+    /** End time for the recurrence schedule in ISO 8601 format. */
+    endTime?: string;
+    /** Time zone for the recurrence schedule. */
+    timeZone?: string;
+    /** Interval for the recurrence schedule. */
+    interval: number;
+    /** Recurrence schedule for the recurrence trigger. */
+    schedule: RecurrenceScheduleUnion;
+}
+export declare function recurrenceTriggerSerializer(item: RecurrenceTrigger): any;
+export declare function recurrenceTriggerDeserializer(item: any): RecurrenceTrigger;
+/** Recurrence schedule model. */
+export interface RecurrenceSchedule {
+    /** Recurrence type for the recurrence schedule. */
+    /** The discriminator possible values: Hourly, Daily, Weekly, Monthly */
+    type: RecurrenceType;
+}
+export declare function recurrenceScheduleSerializer(item: RecurrenceSchedule): any;
+export declare function recurrenceScheduleDeserializer(item: any): RecurrenceSchedule;
+/** Alias for RecurrenceScheduleUnion */
+export type RecurrenceScheduleUnion = HourlyRecurrenceSchedule | DailyRecurrenceSchedule | WeeklyRecurrenceSchedule | MonthlyRecurrenceSchedule | RecurrenceSchedule;
+export declare function recurrenceScheduleUnionSerializer(item: RecurrenceScheduleUnion): any;
+export declare function recurrenceScheduleUnionDeserializer(item: any): RecurrenceScheduleUnion;
+/** Recurrence type. */
+export type RecurrenceType = "Hourly" | "Daily" | "Weekly" | "Monthly";
+/** Hourly recurrence schedule. */
+export interface HourlyRecurrenceSchedule extends RecurrenceSchedule {
+    type: "Hourly";
+}
+export declare function hourlyRecurrenceScheduleSerializer(item: HourlyRecurrenceSchedule): any;
+export declare function hourlyRecurrenceScheduleDeserializer(item: any): HourlyRecurrenceSchedule;
+/** Daily recurrence schedule. */
+export interface DailyRecurrenceSchedule extends RecurrenceSchedule {
+    /** Daily recurrence type. */
+    type: "Daily";
+    /** Hours for the recurrence schedule. */
+    hours: number[];
+}
+export declare function dailyRecurrenceScheduleSerializer(item: DailyRecurrenceSchedule): any;
+export declare function dailyRecurrenceScheduleDeserializer(item: any): DailyRecurrenceSchedule;
+/** Weekly recurrence schedule. */
+export interface WeeklyRecurrenceSchedule extends RecurrenceSchedule {
+    /** Weekly recurrence type. */
+    type: "Weekly";
+    /** Days of the week for the recurrence schedule. */
+    daysOfWeek: DayOfWeek[];
+}
+export declare function weeklyRecurrenceScheduleSerializer(item: WeeklyRecurrenceSchedule): any;
+export declare function weeklyRecurrenceScheduleDeserializer(item: any): WeeklyRecurrenceSchedule;
+/** Days of the week for recurrence schedule. */
+export type DayOfWeek = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";
+/** Monthly recurrence schedule. */
+export interface MonthlyRecurrenceSchedule extends RecurrenceSchedule {
+    /** Monthly recurrence type. */
+    type: "Monthly";
+    /** Days of the month for the recurrence schedule. */
+    daysOfMonth: number[];
+}
+export declare function monthlyRecurrenceScheduleSerializer(item: MonthlyRecurrenceSchedule): any;
+export declare function monthlyRecurrenceScheduleDeserializer(item: any): MonthlyRecurrenceSchedule;
+/** One-time trigger. */
+export interface OneTimeTrigger extends Trigger {
+    type: "OneTime";
+    /** Date and time for the one-time trigger in ISO 8601 format. */
+    triggerAt: string;
+    /** Time zone for the one-time trigger. */
+    timeZone?: string;
+}
+export declare function oneTimeTriggerSerializer(item: OneTimeTrigger): any;
+export declare function oneTimeTriggerDeserializer(item: any): OneTimeTrigger;
+/** Schedule task model. */
+export interface ScheduleTask {
+    /** Type of the task. */
+    /** The discriminator possible values: Evaluation, Insight */
+    type: ScheduleTaskType;
+    /** Configuration for the task. */
+    configuration?: Record<string, string>;
+}
+export declare function scheduleTaskSerializer(item: ScheduleTask): any;
+export declare function scheduleTaskDeserializer(item: any): ScheduleTask;
+/** Alias for ScheduleTaskUnion */
+export type ScheduleTaskUnion = EvaluationScheduleTask | InsightScheduleTask | ScheduleTask;
+export declare function scheduleTaskUnionSerializer(item: ScheduleTaskUnion): any;
+export declare function scheduleTaskUnionDeserializer(item: any): ScheduleTaskUnion;
+/** Type of the task. */
+export type ScheduleTaskType = "Evaluation" | "Insight";
+/** Evaluation task for the schedule. */
+export interface EvaluationScheduleTask extends ScheduleTask {
+    type: "Evaluation";
+    /** Identifier of the evaluation group. */
+    evalId: string;
+    /** The evaluation run payload. */
+    evalRun: Record<string, any>;
+}
+export declare function evaluationScheduleTaskSerializer(item: EvaluationScheduleTask): any;
+export declare function evaluationScheduleTaskDeserializer(item: any): EvaluationScheduleTask;
+/** model interface _EvaluationScheduleTaskEvalRun */
+export interface _EvaluationScheduleTaskEvalRun {
+}
+export declare function _evaluationScheduleTaskEvalRunSerializer(item: _EvaluationScheduleTaskEvalRun): any;
+export declare function _evaluationScheduleTaskEvalRunDeserializer(item: any): _EvaluationScheduleTaskEvalRun;
+/** Insight task for the schedule. */
+export interface InsightScheduleTask extends ScheduleTask {
+    type: "Insight";
+    /** The insight payload. */
+    insight: Insight;
+}
+export declare function insightScheduleTaskSerializer(item: InsightScheduleTask): any;
+export declare function insightScheduleTaskDeserializer(item: any): InsightScheduleTask;
+/** Paged collection of Schedule items */
+export interface _PagedSchedule {
+    /** The Schedule items on this page */
+    value: Schedule[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedScheduleDeserializer(item: any): _PagedSchedule;
+export declare function scheduleArraySerializer(result: Array<Schedule>): any[];
+export declare function scheduleArrayDeserializer(result: Array<Schedule>): any[];
+/** Schedule run model. */
+export interface ScheduleRun {
+    /** Identifier of the schedule run. */
+    readonly id: string;
+    /** Identifier of the schedule. */
+    scheduleId: string;
+    /** Trigger success status of the schedule run. */
+    readonly success: boolean;
+    /** Trigger time of the schedule run. */
+    triggerTime?: string;
+    /** Error information for the schedule run. */
+    readonly error?: string;
+    /** Properties of the schedule run. */
+    readonly properties: Record<string, string>;
+}
+export declare function scheduleRunDeserializer(item: any): ScheduleRun;
+/** Paged collection of ScheduleRun items */
+export interface PagedScheduleRun {
+    /** The ScheduleRun items on this page */
+    value: ScheduleRun[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function pagedScheduleRunDeserializer(item: any): PagedScheduleRun;
+export declare function scheduleRunArrayDeserializer(result: Array<ScheduleRun>): any[];
+/** model interface AgentId */
+export interface AgentId {
+    type: "agent_id";
+    /** The name of the agent. */
+    name: string;
+    /** The version identifier of the agent. */
+    version: string;
+}
+export declare function agentIdDeserializer(item: any): AgentId;
+/** Alias for _ResponseInstructions */
+export type _ResponseInstructions = string | ItemParamUnion[];
+/** model interface AgentReference */
+export interface AgentReference {
+    type: "agent_reference";
+    /** The name of the agent. */
+    name: string;
+    /** The version identifier of the agent. */
+    version?: string;
+}
+export declare function agentReferenceSerializer(item: AgentReference): any;
+/** Alias for _ListVersionsRequestType */
+export type _ListVersionsRequestType = EvaluatorType | "all";
+export declare function _listVersionsRequestTypeSerializer(item: _ListVersionsRequestType): any;
 /** The type of pending upload. */
 export type PendingUploadType = "None" | "BlobReference";
 /** Azure AI Projects API versions */
-export declare enum KnownVersions {
-    /** Azure AI API version 2025-05-01. */
-    V20250501 = "2025-05-01",
-    /** Azure AI API version v1. */
-    V1 = "v1"
+export declare enum KnownApiVersions {
+    /** Azure AI API version 2025-11-15-preview. */
+    v2025_11_15_preview = "2025-11-15-preview"
 }
 //# sourceMappingURL=models.d.ts.map