import * as z from "zod/v3";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolRequestBodyToolsRequest5Status: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolRequestBodyToolsRequest5Status = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest5Status>;
/**
 * The type must be "object"
 */
export declare const UpdateToolRequestBodyToolsRequest5CodeToolType: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type UpdateToolRequestBodyToolsRequest5CodeToolType = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest5CodeToolType>;
/**
 * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type UpdateToolRequestBodyToolsParameters = {
    /**
     * The type must be "object"
     */
    type: UpdateToolRequestBodyToolsRequest5CodeToolType;
    /**
     * The properties of the function parameters
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required parameter names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export declare const UpdateToolRequestBodyLanguage: {
    readonly Python: "python";
};
export type UpdateToolRequestBodyLanguage = ClosedEnum<typeof UpdateToolRequestBodyLanguage>;
export type UpdateToolRequestBodyCodeTool = {
    /**
     * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
     */
    parameters?: UpdateToolRequestBodyToolsParameters | undefined;
    language: UpdateToolRequestBodyLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
export declare const UpdateToolRequestBodyToolsRequest5VersionIncrement: {
    readonly Major: "major";
    readonly Minor: "minor";
    readonly Patch: "patch";
};
export type UpdateToolRequestBodyToolsRequest5VersionIncrement = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest5VersionIncrement>;
/**
 * Updates an existing code execution tool configuration.
 */
export type UpdateCodeExecutionTool = {
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path?: string | undefined;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key?: string | undefined;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description?: string | undefined;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status?: UpdateToolRequestBodyToolsRequest5Status | undefined;
    type: "code";
    codeTool?: UpdateToolRequestBodyCodeTool | undefined;
    versionIncrement?: UpdateToolRequestBodyToolsRequest5VersionIncrement | undefined;
    versionDescription?: string | undefined;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolRequestBodyToolsRequest4Status: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolRequestBodyToolsRequest4Status = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest4Status>;
export type UpdateToolRequestBodyHeaders = {
    value: string;
    encrypted?: boolean | undefined;
};
export declare const UpdateToolRequestBodyToolsRequest4McpType: {
    readonly Object: "object";
};
export type UpdateToolRequestBodyToolsRequest4McpType = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest4McpType>;
export type UpdateToolRequestBodyToolsSchema = {
    type: UpdateToolRequestBodyToolsRequest4McpType;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
export type RequestBodyTools = {
    id?: string | undefined;
    name: string;
    description?: string | undefined;
    schema: UpdateToolRequestBodyToolsSchema;
};
/**
 * The connection type used by the MCP server
 */
export declare const UpdateToolRequestBodyConnectionType: {
    readonly Http: "http";
    readonly Sse: "sse";
};
/**
 * The connection type used by the MCP server
 */
export type UpdateToolRequestBodyConnectionType = ClosedEnum<typeof UpdateToolRequestBodyConnectionType>;
export type UpdateToolRequestBodyMcp = {
    /**
     * The MCP server URL (cached for execution)
     */
    serverUrl?: string | undefined;
    /**
     * HTTP headers for MCP server requests with encryption support
     */
    headers?: {
        [k: string]: UpdateToolRequestBodyHeaders;
    } | undefined;
    /**
     * Array of tools available from the MCP server
     */
    tools?: Array<RequestBodyTools> | undefined;
    /**
     * The connection type used by the MCP server
     */
    connectionType?: UpdateToolRequestBodyConnectionType | undefined;
};
export declare const UpdateToolRequestBodyToolsRequestVersionIncrement: {
    readonly Major: "major";
    readonly Minor: "minor";
    readonly Patch: "patch";
};
export type UpdateToolRequestBodyToolsRequestVersionIncrement = ClosedEnum<typeof UpdateToolRequestBodyToolsRequestVersionIncrement>;
/**
 * Updates an existing MCP tool configuration.
 */
export type UpdateMCPTool = {
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path?: string | undefined;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key?: string | undefined;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description?: string | undefined;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status?: UpdateToolRequestBodyToolsRequest4Status | undefined;
    type: "mcp";
    mcp?: UpdateToolRequestBodyMcp | undefined;
    versionIncrement?: UpdateToolRequestBodyToolsRequestVersionIncrement | undefined;
    versionDescription?: string | undefined;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolRequestBodyToolsRequestStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolRequestBodyToolsRequestStatus = ClosedEnum<typeof UpdateToolRequestBodyToolsRequestStatus>;
/**
 * The HTTP method to use.
 */
export declare const UpdateToolRequestBodyMethod: {
    readonly Get: "GET";
    readonly Post: "POST";
    readonly Put: "PUT";
    readonly Delete: "DELETE";
};
/**
 * The HTTP method to use.
 */
export type UpdateToolRequestBodyMethod = ClosedEnum<typeof UpdateToolRequestBodyMethod>;
export type UpdateToolHeaders2 = {
    value: string;
    encrypted?: boolean | undefined;
};
export type UpdateToolRequestBodyToolsHeaders = UpdateToolHeaders2 | string;
/**
 * The blueprint for the HTTP request. The `arguments` field will be used to replace the placeholders in the `url`, `headers`, `body`, and `arguments` fields.
 */
export type UpdateToolRequestBodyBlueprint = {
    /**
     * The URL to send the request to.
     */
    url: string;
    /**
     * The HTTP method to use.
     */
    method: UpdateToolRequestBodyMethod;
    /**
     * The headers to send with the request. Can be a string value or an object with value and encrypted properties.
     */
    headers?: {
        [k: string]: UpdateToolHeaders2 | string;
    } | undefined;
    /**
     * The body to send with the request.
     */
    body?: {
        [k: string]: any;
    } | undefined;
};
/**
 * The type of the argument.
 */
export declare const UpdateToolRequestBodyToolsRequest3Type: {
    readonly String: "string";
    readonly Number: "number";
    readonly Boolean: "boolean";
};
/**
 * The type of the argument.
 */
export type UpdateToolRequestBodyToolsRequest3Type = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest3Type>;
/**
 * The default value of the argument.
 */
export type UpdateToolRequestBodyDefaultValue = string | number | boolean;
export type UpdateToolRequestBodyArguments = {
    /**
     * The type of the argument.
     */
    type: UpdateToolRequestBodyToolsRequest3Type;
    /**
     * A description of the argument.
     */
    description: string;
    /**
     * Whether to send the argument to the model. If set to false, the argument will not be sent to the model and needs to be provided by the user or it will be left blank.
     */
    sendToModel?: boolean | undefined;
    /**
     * The default value of the argument.
     */
    defaultValue?: string | number | boolean | undefined;
};
export type UpdateToolRequestBodyHttp = {
    /**
     * The blueprint for the HTTP request. The `arguments` field will be used to replace the placeholders in the `url`, `headers`, `body`, and `arguments` fields.
     */
    blueprint: UpdateToolRequestBodyBlueprint;
    /**
     * The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field.
     */
    arguments?: {
        [k: string]: UpdateToolRequestBodyArguments;
    } | undefined;
};
export declare const UpdateToolRequestBodyToolsVersionIncrement: {
    readonly Major: "major";
    readonly Minor: "minor";
    readonly Patch: "patch";
};
export type UpdateToolRequestBodyToolsVersionIncrement = ClosedEnum<typeof UpdateToolRequestBodyToolsVersionIncrement>;
/**
 * Updates an existing HTTP tool configuration.
 */
export type UpdateHTTPTool = {
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path?: string | undefined;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key?: string | undefined;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description?: string | undefined;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status?: UpdateToolRequestBodyToolsRequestStatus | undefined;
    type: "http";
    http?: UpdateToolRequestBodyHttp | undefined;
    versionIncrement?: UpdateToolRequestBodyToolsVersionIncrement | undefined;
    versionDescription?: string | undefined;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolRequestBodyToolsStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolRequestBodyToolsStatus = ClosedEnum<typeof UpdateToolRequestBodyToolsStatus>;
/**
 * The schema for the response format, described as a JSON Schema object. See the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type UpdateToolRequestBodySchema = {
    /**
     * The JSON Schema type
     */
    type: string;
    /**
     * The properties of the JSON Schema object
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required property names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export type UpdateToolRequestBodyJsonSchema = {
    /**
     * 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;
    /**
     * A description of what the response format is for. This will be shown to the user.
     */
    description: string;
    /**
     * The schema for the response format, described as a JSON Schema object. See the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
     */
    schema: UpdateToolRequestBodySchema;
    /**
     * 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`. Only compatible with `OpenAI` models.
     */
    strict?: boolean | undefined;
};
export declare const UpdateToolRequestBodyVersionIncrement: {
    readonly Major: "major";
    readonly Minor: "minor";
    readonly Patch: "patch";
};
export type UpdateToolRequestBodyVersionIncrement = ClosedEnum<typeof UpdateToolRequestBodyVersionIncrement>;
/**
 * Updates an existing JSON Schema tool configuration.
 */
export type UpdateJSONSchemaTool = {
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path?: string | undefined;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key?: string | undefined;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description?: string | undefined;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status?: UpdateToolRequestBodyToolsStatus | undefined;
    type: "json_schema";
    jsonSchema?: UpdateToolRequestBodyJsonSchema | undefined;
    versionIncrement?: UpdateToolRequestBodyVersionIncrement | undefined;
    versionDescription?: string | undefined;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolRequestBodyStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolRequestBodyStatus = ClosedEnum<typeof UpdateToolRequestBodyStatus>;
/**
 * The type must be "object"
 */
export declare const UpdateToolRequestBodyToolsRequest1Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type UpdateToolRequestBodyToolsRequest1Type = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest1Type>;
/**
 * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type UpdateToolRequestBodyParameters = {
    /**
     * The type must be "object"
     */
    type: UpdateToolRequestBodyToolsRequest1Type;
    /**
     * The properties of the function parameters
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required parameter names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export type UpdateToolRequestBodyFunction = {
    /**
     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
     */
    name: string;
    /**
     * A description of what the function does, used by the model to choose when and how to call the function.
     */
    description?: string | undefined;
    /**
     * Whether to enable strict schema adherence when generating the function call. If set to true, the model will follow the exact schema defined in the `parameters` field. Only a subset of JSON Schema is supported when `strict` is `true`. Currently only compatible with `OpenAI` models.
     */
    strict?: boolean | undefined;
    /**
     * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
     */
    parameters?: UpdateToolRequestBodyParameters | undefined;
};
export declare const RequestBodyVersionIncrement: {
    readonly Major: "major";
    readonly Minor: "minor";
    readonly Patch: "patch";
};
export type RequestBodyVersionIncrement = ClosedEnum<typeof RequestBodyVersionIncrement>;
/**
 * Updates an existing function tool configuration.
 */
export type UpdateFunctionTool = {
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path?: string | undefined;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key?: string | undefined;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description?: string | undefined;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status?: UpdateToolRequestBodyStatus | undefined;
    type: "function";
    function?: UpdateToolRequestBodyFunction | undefined;
    versionIncrement?: RequestBodyVersionIncrement | undefined;
    versionDescription?: string | undefined;
};
/**
 * The tool to update
 */
export type UpdateToolRequestBody = UpdateFunctionTool | UpdateJSONSchemaTool | UpdateHTTPTool | UpdateMCPTool | UpdateCodeExecutionTool;
export type UpdateToolRequest = {
    toolId: string;
    /**
     * The tool to update
     */
    requestBody?: UpdateFunctionTool | UpdateJSONSchemaTool | UpdateHTTPTool | UpdateMCPTool | UpdateCodeExecutionTool | undefined;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus>;
/**
 * The type must be "object"
 */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson5Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type UpdateToolResponseBodyToolsResponse200ApplicationJson5Type = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson5Type>;
/**
 * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type UpdateToolResponseBodyToolsParameters = {
    /**
     * The type must be "object"
     */
    type: UpdateToolResponseBodyToolsResponse200ApplicationJson5Type;
    /**
     * The properties of the function parameters
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required parameter names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export declare const UpdateToolResponseBodyLanguage: {
    readonly Python: "python";
};
export type UpdateToolResponseBodyLanguage = ClosedEnum<typeof UpdateToolResponseBodyLanguage>;
export type UpdateToolResponseBodyCodeTool = {
    /**
     * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
     */
    parameters?: UpdateToolResponseBodyToolsParameters | undefined;
    language: UpdateToolResponseBodyLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
/**
 * Executes code snippets in a sandboxed environment, currently supporting Python.
 */
export type UpdateToolResponseBodyCodeExecutionTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus;
    versionHash?: string | undefined;
    type: "code";
    codeTool: UpdateToolResponseBodyCodeTool;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolResponseBodyToolsResponse200Status: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolResponseBodyToolsResponse200Status = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200Status>;
export type UpdateToolResponseBodyHeaders = {
    value: string;
    encrypted: boolean;
};
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson4Type: {
    readonly Object: "object";
};
export type UpdateToolResponseBodyToolsResponse200ApplicationJson4Type = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson4Type>;
export type UpdateToolResponseBodyToolsSchema = {
    type: UpdateToolResponseBodyToolsResponse200ApplicationJson4Type;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
export type UpdateToolResponseBodyTools = {
    id: string;
    name: string;
    description?: string | undefined;
    schema: UpdateToolResponseBodyToolsSchema;
};
/**
 * The connection type used by the MCP server
 */
export declare const UpdateToolResponseBodyConnectionType: {
    readonly Http: "http";
    readonly Sse: "sse";
};
/**
 * The connection type used by the MCP server
 */
export type UpdateToolResponseBodyConnectionType = ClosedEnum<typeof UpdateToolResponseBodyConnectionType>;
export type UpdateToolResponseBodyMcp = {
    /**
     * The MCP server URL (cached for execution)
     */
    serverUrl: string;
    /**
     * HTTP headers for MCP server requests with encryption support
     */
    headers?: {
        [k: string]: UpdateToolResponseBodyHeaders;
    } | undefined;
    /**
     * Array of tools available from the MCP server
     */
    tools: Array<UpdateToolResponseBodyTools>;
    /**
     * The connection type used by the MCP server
     */
    connectionType: UpdateToolResponseBodyConnectionType;
};
/**
 * A tool from a Model Context Protocol (MCP) server that provides standardized access to external capabilities.
 */
export type UpdateToolResponseBodyMCPTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: UpdateToolResponseBodyToolsResponse200Status;
    versionHash?: string | undefined;
    type: "mcp";
    mcp: UpdateToolResponseBodyMcp;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolResponseBodyToolsResponseStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolResponseBodyToolsResponseStatus = ClosedEnum<typeof UpdateToolResponseBodyToolsResponseStatus>;
/**
 * The HTTP method to use.
 */
export declare const UpdateToolResponseBodyMethod: {
    readonly Get: "GET";
    readonly Post: "POST";
    readonly Put: "PUT";
    readonly Delete: "DELETE";
};
/**
 * The HTTP method to use.
 */
export type UpdateToolResponseBodyMethod = ClosedEnum<typeof UpdateToolResponseBodyMethod>;
export type UpdateToolHeadersTools2 = {
    value: string;
    encrypted: boolean;
};
export type UpdateToolResponseBodyToolsHeaders = UpdateToolHeadersTools2 | string;
/**
 * The blueprint for the HTTP request. The `arguments` field will be used to replace the placeholders in the `url`, `headers`, `body`, and `arguments` fields.
 */
export type UpdateToolResponseBodyBlueprint = {
    /**
     * The URL to send the request to.
     */
    url: string;
    /**
     * The HTTP method to use.
     */
    method: UpdateToolResponseBodyMethod;
    /**
     * The headers to send with the request. Can be a string value or an object with value and encrypted properties.
     */
    headers?: {
        [k: string]: UpdateToolHeadersTools2 | string;
    } | undefined;
    /**
     * The body to send with the request.
     */
    body?: {
        [k: string]: any;
    } | undefined;
};
/**
 * The type of the argument.
 */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson3Type: {
    readonly String: "string";
    readonly Number: "number";
    readonly Boolean: "boolean";
};
/**
 * The type of the argument.
 */
export type UpdateToolResponseBodyToolsResponse200ApplicationJson3Type = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/**
 * The default value of the argument.
 */
export type UpdateToolResponseBodyDefaultValue = string | number | boolean;
export type UpdateToolResponseBodyArguments = {
    /**
     * The type of the argument.
     */
    type: UpdateToolResponseBodyToolsResponse200ApplicationJson3Type;
    /**
     * A description of the argument.
     */
    description: string;
    /**
     * Whether to send the argument to the model. If set to false, the argument will not be sent to the model and needs to be provided by the user or it will be left blank.
     */
    sendToModel: boolean;
    /**
     * The default value of the argument.
     */
    defaultValue?: string | number | boolean | undefined;
};
export type UpdateToolResponseBodyHttp = {
    /**
     * The blueprint for the HTTP request. The `arguments` field will be used to replace the placeholders in the `url`, `headers`, `body`, and `arguments` fields.
     */
    blueprint: UpdateToolResponseBodyBlueprint;
    /**
     * The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field.
     */
    arguments?: {
        [k: string]: UpdateToolResponseBodyArguments;
    } | undefined;
};
/**
 * Executes HTTP requests to interact with external APIs and web services using customizable blueprints.
 */
export type UpdateToolResponseBodyHTTPTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: UpdateToolResponseBodyToolsResponseStatus;
    versionHash?: string | undefined;
    type: "http";
    http: UpdateToolResponseBodyHttp;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolResponseBodyToolsStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolResponseBodyToolsStatus = ClosedEnum<typeof UpdateToolResponseBodyToolsStatus>;
/**
 * The schema for the response format, described as a JSON Schema object. See the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type UpdateToolResponseBodySchema = {
    /**
     * The JSON Schema type
     */
    type: string;
    /**
     * The properties of the JSON Schema object
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required property names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export type UpdateToolResponseBodyJsonSchema = {
    /**
     * 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;
    /**
     * A description of what the response format is for. This will be shown to the user.
     */
    description: string;
    /**
     * The schema for the response format, described as a JSON Schema object. See the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
     */
    schema: UpdateToolResponseBodySchema;
    /**
     * 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`. Only compatible with `OpenAI` models.
     */
    strict?: boolean | undefined;
};
/**
 * A tool that enforces structured output format using JSON Schema for consistent response formatting.
 */
export type UpdateToolResponseBodyJSONSchemaTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: UpdateToolResponseBodyToolsStatus;
    versionHash?: string | undefined;
    type: "json_schema";
    jsonSchema: UpdateToolResponseBodyJsonSchema;
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export declare const UpdateToolResponseBodyStatus: {
    readonly Live: "live";
    readonly Draft: "draft";
    readonly Pending: "pending";
    readonly Published: "published";
};
/**
 * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
 */
export type UpdateToolResponseBodyStatus = ClosedEnum<typeof UpdateToolResponseBodyStatus>;
/**
 * The type must be "object"
 */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson1Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type UpdateToolResponseBodyToolsResponse200ApplicationJson1Type = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson1Type>;
/**
 * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type UpdateToolResponseBodyParameters = {
    /**
     * The type must be "object"
     */
    type: UpdateToolResponseBodyToolsResponse200ApplicationJson1Type;
    /**
     * The properties of the function parameters
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required parameter names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export type UpdateToolResponseBodyFunction = {
    /**
     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
     */
    name: string;
    /**
     * A description of what the function does, used by the model to choose when and how to call the function.
     */
    description?: string | undefined;
    /**
     * Whether to enable strict schema adherence when generating the function call. If set to true, the model will follow the exact schema defined in the `parameters` field. Only a subset of JSON Schema is supported when `strict` is `true`. Currently only compatible with `OpenAI` models.
     */
    strict?: boolean | undefined;
    /**
     * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
     */
    parameters?: UpdateToolResponseBodyParameters | undefined;
};
/**
 * A custom function tool that allows the model to call predefined functions with structured parameters.
 */
export type UpdateToolResponseBodyFunctionTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: UpdateToolResponseBodyStatus;
    versionHash?: string | undefined;
    type: "function";
    function: UpdateToolResponseBodyFunction;
};
/**
 * Successfully updated the tool.
 */
export type UpdateToolResponseBody = UpdateToolResponseBodyFunctionTool | UpdateToolResponseBodyJSONSchemaTool | UpdateToolResponseBodyHTTPTool | UpdateToolResponseBodyMCPTool | UpdateToolResponseBodyCodeExecutionTool;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5Status$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5Status>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5CodeToolType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5CodeToolType>;
/** @internal */
export type UpdateToolRequestBodyToolsParameters$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const UpdateToolRequestBodyToolsParameters$outboundSchema: z.ZodType<UpdateToolRequestBodyToolsParameters$Outbound, z.ZodTypeDef, UpdateToolRequestBodyToolsParameters>;
export declare function updateToolRequestBodyToolsParametersToJSON(updateToolRequestBodyToolsParameters: UpdateToolRequestBodyToolsParameters): string;
/** @internal */
export declare const UpdateToolRequestBodyLanguage$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyLanguage>;
/** @internal */
export type UpdateToolRequestBodyCodeTool$Outbound = {
    parameters?: UpdateToolRequestBodyToolsParameters$Outbound | undefined;
    language: string;
    code: string;
};
/** @internal */
export declare const UpdateToolRequestBodyCodeTool$outboundSchema: z.ZodType<UpdateToolRequestBodyCodeTool$Outbound, z.ZodTypeDef, UpdateToolRequestBodyCodeTool>;
export declare function updateToolRequestBodyCodeToolToJSON(updateToolRequestBodyCodeTool: UpdateToolRequestBodyCodeTool): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5VersionIncrement$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5VersionIncrement>;
/** @internal */
export type UpdateCodeExecutionTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: "code";
    code_tool?: UpdateToolRequestBodyCodeTool$Outbound | undefined;
    versionIncrement?: string | undefined;
    versionDescription?: string | undefined;
};
/** @internal */
export declare const UpdateCodeExecutionTool$outboundSchema: z.ZodType<UpdateCodeExecutionTool$Outbound, z.ZodTypeDef, UpdateCodeExecutionTool>;
export declare function updateCodeExecutionToolToJSON(updateCodeExecutionTool: UpdateCodeExecutionTool): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4Status$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4Status>;
/** @internal */
export type UpdateToolRequestBodyHeaders$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const UpdateToolRequestBodyHeaders$outboundSchema: z.ZodType<UpdateToolRequestBodyHeaders$Outbound, z.ZodTypeDef, UpdateToolRequestBodyHeaders>;
export declare function updateToolRequestBodyHeadersToJSON(updateToolRequestBodyHeaders: UpdateToolRequestBodyHeaders): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4McpType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4McpType>;
/** @internal */
export type UpdateToolRequestBodyToolsSchema$Outbound = {
    type: string;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyToolsSchema$outboundSchema: z.ZodType<UpdateToolRequestBodyToolsSchema$Outbound, z.ZodTypeDef, UpdateToolRequestBodyToolsSchema>;
export declare function updateToolRequestBodyToolsSchemaToJSON(updateToolRequestBodyToolsSchema: UpdateToolRequestBodyToolsSchema): string;
/** @internal */
export type RequestBodyTools$Outbound = {
    id: string;
    name: string;
    description?: string | undefined;
    schema: UpdateToolRequestBodyToolsSchema$Outbound;
};
/** @internal */
export declare const RequestBodyTools$outboundSchema: z.ZodType<RequestBodyTools$Outbound, z.ZodTypeDef, RequestBodyTools>;
export declare function requestBodyToolsToJSON(requestBodyTools: RequestBodyTools): string;
/** @internal */
export declare const UpdateToolRequestBodyConnectionType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyConnectionType>;
/** @internal */
export type UpdateToolRequestBodyMcp$Outbound = {
    server_url?: string | undefined;
    headers?: {
        [k: string]: UpdateToolRequestBodyHeaders$Outbound;
    } | undefined;
    tools?: Array<RequestBodyTools$Outbound> | undefined;
    connection_type?: string | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyMcp$outboundSchema: z.ZodType<UpdateToolRequestBodyMcp$Outbound, z.ZodTypeDef, UpdateToolRequestBodyMcp>;
export declare function updateToolRequestBodyMcpToJSON(updateToolRequestBodyMcp: UpdateToolRequestBodyMcp): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequestVersionIncrement$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequestVersionIncrement>;
/** @internal */
export type UpdateMCPTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: "mcp";
    mcp?: UpdateToolRequestBodyMcp$Outbound | undefined;
    versionIncrement?: string | undefined;
    versionDescription?: string | undefined;
};
/** @internal */
export declare const UpdateMCPTool$outboundSchema: z.ZodType<UpdateMCPTool$Outbound, z.ZodTypeDef, UpdateMCPTool>;
export declare function updateMCPToolToJSON(updateMCPTool: UpdateMCPTool): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequestStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequestStatus>;
/** @internal */
export declare const UpdateToolRequestBodyMethod$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyMethod>;
/** @internal */
export type UpdateToolHeaders2$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const UpdateToolHeaders2$outboundSchema: z.ZodType<UpdateToolHeaders2$Outbound, z.ZodTypeDef, UpdateToolHeaders2>;
export declare function updateToolHeaders2ToJSON(updateToolHeaders2: UpdateToolHeaders2): string;
/** @internal */
export type UpdateToolRequestBodyToolsHeaders$Outbound = UpdateToolHeaders2$Outbound | string;
/** @internal */
export declare const UpdateToolRequestBodyToolsHeaders$outboundSchema: z.ZodType<UpdateToolRequestBodyToolsHeaders$Outbound, z.ZodTypeDef, UpdateToolRequestBodyToolsHeaders>;
export declare function updateToolRequestBodyToolsHeadersToJSON(updateToolRequestBodyToolsHeaders: UpdateToolRequestBodyToolsHeaders): string;
/** @internal */
export type UpdateToolRequestBodyBlueprint$Outbound = {
    url: string;
    method: string;
    headers?: {
        [k: string]: UpdateToolHeaders2$Outbound | string;
    } | undefined;
    body?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyBlueprint$outboundSchema: z.ZodType<UpdateToolRequestBodyBlueprint$Outbound, z.ZodTypeDef, UpdateToolRequestBodyBlueprint>;
export declare function updateToolRequestBodyBlueprintToJSON(updateToolRequestBodyBlueprint: UpdateToolRequestBodyBlueprint): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest3Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest3Type>;
/** @internal */
export type UpdateToolRequestBodyDefaultValue$Outbound = string | number | boolean;
/** @internal */
export declare const UpdateToolRequestBodyDefaultValue$outboundSchema: z.ZodType<UpdateToolRequestBodyDefaultValue$Outbound, z.ZodTypeDef, UpdateToolRequestBodyDefaultValue>;
export declare function updateToolRequestBodyDefaultValueToJSON(updateToolRequestBodyDefaultValue: UpdateToolRequestBodyDefaultValue): string;
/** @internal */
export type UpdateToolRequestBodyArguments$Outbound = {
    type: string;
    description: string;
    send_to_model: boolean;
    default_value?: string | number | boolean | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyArguments$outboundSchema: z.ZodType<UpdateToolRequestBodyArguments$Outbound, z.ZodTypeDef, UpdateToolRequestBodyArguments>;
export declare function updateToolRequestBodyArgumentsToJSON(updateToolRequestBodyArguments: UpdateToolRequestBodyArguments): string;
/** @internal */
export type UpdateToolRequestBodyHttp$Outbound = {
    blueprint: UpdateToolRequestBodyBlueprint$Outbound;
    arguments?: {
        [k: string]: UpdateToolRequestBodyArguments$Outbound;
    } | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyHttp$outboundSchema: z.ZodType<UpdateToolRequestBodyHttp$Outbound, z.ZodTypeDef, UpdateToolRequestBodyHttp>;
export declare function updateToolRequestBodyHttpToJSON(updateToolRequestBodyHttp: UpdateToolRequestBodyHttp): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsVersionIncrement$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsVersionIncrement>;
/** @internal */
export type UpdateHTTPTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: "http";
    http?: UpdateToolRequestBodyHttp$Outbound | undefined;
    versionIncrement?: string | undefined;
    versionDescription?: string | undefined;
};
/** @internal */
export declare const UpdateHTTPTool$outboundSchema: z.ZodType<UpdateHTTPTool$Outbound, z.ZodTypeDef, UpdateHTTPTool>;
export declare function updateHTTPToolToJSON(updateHTTPTool: UpdateHTTPTool): string;
/** @internal */
export declare const UpdateToolRequestBodyToolsStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsStatus>;
/** @internal */
export type UpdateToolRequestBodySchema$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const UpdateToolRequestBodySchema$outboundSchema: z.ZodType<UpdateToolRequestBodySchema$Outbound, z.ZodTypeDef, UpdateToolRequestBodySchema>;
export declare function updateToolRequestBodySchemaToJSON(updateToolRequestBodySchema: UpdateToolRequestBodySchema): string;
/** @internal */
export type UpdateToolRequestBodyJsonSchema$Outbound = {
    name: string;
    description: string;
    schema: UpdateToolRequestBodySchema$Outbound;
    strict?: boolean | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyJsonSchema$outboundSchema: z.ZodType<UpdateToolRequestBodyJsonSchema$Outbound, z.ZodTypeDef, UpdateToolRequestBodyJsonSchema>;
export declare function updateToolRequestBodyJsonSchemaToJSON(updateToolRequestBodyJsonSchema: UpdateToolRequestBodyJsonSchema): string;
/** @internal */
export declare const UpdateToolRequestBodyVersionIncrement$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyVersionIncrement>;
/** @internal */
export type UpdateJSONSchemaTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: "json_schema";
    json_schema?: UpdateToolRequestBodyJsonSchema$Outbound | undefined;
    versionIncrement?: string | undefined;
    versionDescription?: string | undefined;
};
/** @internal */
export declare const UpdateJSONSchemaTool$outboundSchema: z.ZodType<UpdateJSONSchemaTool$Outbound, z.ZodTypeDef, UpdateJSONSchemaTool>;
export declare function updateJSONSchemaToolToJSON(updateJSONSchemaTool: UpdateJSONSchemaTool): string;
/** @internal */
export declare const UpdateToolRequestBodyStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyStatus>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest1Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest1Type>;
/** @internal */
export type UpdateToolRequestBodyParameters$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const UpdateToolRequestBodyParameters$outboundSchema: z.ZodType<UpdateToolRequestBodyParameters$Outbound, z.ZodTypeDef, UpdateToolRequestBodyParameters>;
export declare function updateToolRequestBodyParametersToJSON(updateToolRequestBodyParameters: UpdateToolRequestBodyParameters): string;
/** @internal */
export type UpdateToolRequestBodyFunction$Outbound = {
    name: string;
    description?: string | undefined;
    strict?: boolean | undefined;
    parameters?: UpdateToolRequestBodyParameters$Outbound | undefined;
};
/** @internal */
export declare const UpdateToolRequestBodyFunction$outboundSchema: z.ZodType<UpdateToolRequestBodyFunction$Outbound, z.ZodTypeDef, UpdateToolRequestBodyFunction>;
export declare function updateToolRequestBodyFunctionToJSON(updateToolRequestBodyFunction: UpdateToolRequestBodyFunction): string;
/** @internal */
export declare const RequestBodyVersionIncrement$outboundSchema: z.ZodNativeEnum<typeof RequestBodyVersionIncrement>;
/** @internal */
export type UpdateFunctionTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: "function";
    function?: UpdateToolRequestBodyFunction$Outbound | undefined;
    versionIncrement?: string | undefined;
    versionDescription?: string | undefined;
};
/** @internal */
export declare const UpdateFunctionTool$outboundSchema: z.ZodType<UpdateFunctionTool$Outbound, z.ZodTypeDef, UpdateFunctionTool>;
export declare function updateFunctionToolToJSON(updateFunctionTool: UpdateFunctionTool): string;
/** @internal */
export type UpdateToolRequestBody$Outbound = UpdateFunctionTool$Outbound | UpdateJSONSchemaTool$Outbound | UpdateHTTPTool$Outbound | UpdateMCPTool$Outbound | UpdateCodeExecutionTool$Outbound;
/** @internal */
export declare const UpdateToolRequestBody$outboundSchema: z.ZodType<UpdateToolRequestBody$Outbound, z.ZodTypeDef, UpdateToolRequestBody>;
export declare function updateToolRequestBodyToJSON(updateToolRequestBody: UpdateToolRequestBody): string;
/** @internal */
export type UpdateToolRequest$Outbound = {
    tool_id: string;
    RequestBody?: UpdateFunctionTool$Outbound | UpdateJSONSchemaTool$Outbound | UpdateHTTPTool$Outbound | UpdateMCPTool$Outbound | UpdateCodeExecutionTool$Outbound | undefined;
};
/** @internal */
export declare const UpdateToolRequest$outboundSchema: z.ZodType<UpdateToolRequest$Outbound, z.ZodTypeDef, UpdateToolRequest>;
export declare function updateToolRequestToJSON(updateToolRequest: UpdateToolRequest): string;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson5Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson5Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsParameters$inboundSchema: z.ZodType<UpdateToolResponseBodyToolsParameters, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyToolsParametersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyToolsParameters, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyLanguage$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyLanguage>;
/** @internal */
export declare const UpdateToolResponseBodyCodeTool$inboundSchema: z.ZodType<UpdateToolResponseBodyCodeTool, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyCodeToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyCodeTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyCodeExecutionTool$inboundSchema: z.ZodType<UpdateToolResponseBodyCodeExecutionTool, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyCodeExecutionToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyCodeExecutionTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200Status$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200Status>;
/** @internal */
export declare const UpdateToolResponseBodyHeaders$inboundSchema: z.ZodType<UpdateToolResponseBodyHeaders, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyHeadersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyHeaders, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson4Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsSchema$inboundSchema: z.ZodType<UpdateToolResponseBodyToolsSchema, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyToolsSchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyToolsSchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyTools$inboundSchema: z.ZodType<UpdateToolResponseBodyTools, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyToolsFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyTools, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyConnectionType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyConnectionType>;
/** @internal */
export declare const UpdateToolResponseBodyMcp$inboundSchema: z.ZodType<UpdateToolResponseBodyMcp, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyMcpFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyMcp, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyMCPTool$inboundSchema: z.ZodType<UpdateToolResponseBodyMCPTool, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyMCPToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyMCPTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponseStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponseStatus>;
/** @internal */
export declare const UpdateToolResponseBodyMethod$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyMethod>;
/** @internal */
export declare const UpdateToolHeadersTools2$inboundSchema: z.ZodType<UpdateToolHeadersTools2, z.ZodTypeDef, unknown>;
export declare function updateToolHeadersTools2FromJSON(jsonString: string): SafeParseResult<UpdateToolHeadersTools2, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsHeaders$inboundSchema: z.ZodType<UpdateToolResponseBodyToolsHeaders, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyToolsHeadersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyToolsHeaders, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyBlueprint$inboundSchema: z.ZodType<UpdateToolResponseBodyBlueprint, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyBlueprintFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyBlueprint, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson3Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/** @internal */
export declare const UpdateToolResponseBodyDefaultValue$inboundSchema: z.ZodType<UpdateToolResponseBodyDefaultValue, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyDefaultValueFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyDefaultValue, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyArguments$inboundSchema: z.ZodType<UpdateToolResponseBodyArguments, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyArgumentsFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyArguments, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyHttp$inboundSchema: z.ZodType<UpdateToolResponseBodyHttp, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyHttpFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyHttp, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyHTTPTool$inboundSchema: z.ZodType<UpdateToolResponseBodyHTTPTool, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyHTTPToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyHTTPTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsStatus>;
/** @internal */
export declare const UpdateToolResponseBodySchema$inboundSchema: z.ZodType<UpdateToolResponseBodySchema, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodySchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodySchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyJsonSchema$inboundSchema: z.ZodType<UpdateToolResponseBodyJsonSchema, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyJsonSchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyJsonSchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyJSONSchemaTool$inboundSchema: z.ZodType<UpdateToolResponseBodyJSONSchemaTool, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyJSONSchemaToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyJSONSchemaTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson1Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson1Type>;
/** @internal */
export declare const UpdateToolResponseBodyParameters$inboundSchema: z.ZodType<UpdateToolResponseBodyParameters, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyParametersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyParameters, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyFunction$inboundSchema: z.ZodType<UpdateToolResponseBodyFunction, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyFunctionFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyFunction, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyFunctionTool$inboundSchema: z.ZodType<UpdateToolResponseBodyFunctionTool, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyFunctionToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyFunctionTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBody$inboundSchema: z.ZodType<UpdateToolResponseBody, z.ZodTypeDef, unknown>;
export declare function updateToolResponseBodyFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBody, SDKValidationError>;
//# sourceMappingURL=updatetool.d.ts.map