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>;
export declare const UpdateToolRequestBodyToolsRequest5Type: {
    readonly Code: "code";
};
export type UpdateToolRequestBodyToolsRequest5Type = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest5Type>;
/**
 * 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;
};
/**
 * 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: UpdateToolRequestBodyToolsRequest5Type;
    codeTool?: UpdateToolRequestBodyCodeTool | 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 declare const UpdateToolRequestBodyToolsRequest4Type: {
    readonly Mcp: "mcp";
};
export type UpdateToolRequestBodyToolsRequest4Type = ClosedEnum<typeof UpdateToolRequestBodyToolsRequest4Type>;
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;
};
/**
 * 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: UpdateToolRequestBodyToolsRequest4Type;
    mcp?: UpdateToolRequestBodyMcp | 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>;
export declare const UpdateToolRequestBodyToolsRequestType: {
    readonly Http: "http";
};
export type UpdateToolRequestBodyToolsRequestType = ClosedEnum<typeof UpdateToolRequestBodyToolsRequestType>;
/**
 * 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;
};
/**
 * 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: UpdateToolRequestBodyToolsRequestType;
    http?: UpdateToolRequestBodyHttp | 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>;
export declare const UpdateToolRequestBodyToolsType: {
    readonly JsonSchema: "json_schema";
};
export type UpdateToolRequestBodyToolsType = ClosedEnum<typeof UpdateToolRequestBodyToolsType>;
/**
 * 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;
};
/**
 * 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: UpdateToolRequestBodyToolsType;
    jsonSchema?: UpdateToolRequestBodyJsonSchema | 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>;
export declare const UpdateToolRequestBodyType: {
    readonly Function: "function";
};
export type UpdateToolRequestBodyType = ClosedEnum<typeof UpdateToolRequestBodyType>;
/**
 * 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;
};
/**
 * 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: UpdateToolRequestBodyType;
    function?: UpdateToolRequestBodyFunction | 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>;
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONType: {
    readonly Code: "code";
};
export type UpdateToolResponseBodyToolsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONType>;
/**
 * 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 | undefined;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * 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 | undefined;
    versionHash?: string | undefined;
    type: UpdateToolResponseBodyToolsResponse200ApplicationJSONType;
    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 declare const UpdateToolResponseBodyToolsResponse200Type: {
    readonly Mcp: "mcp";
};
export type UpdateToolResponseBodyToolsResponse200Type = ClosedEnum<typeof UpdateToolResponseBodyToolsResponse200Type>;
export type UpdateToolResponseBodyHeaders = {
    value: string;
    encrypted?: boolean | undefined;
};
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 | undefined;
    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 | undefined;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * 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 | undefined;
    versionHash?: string | undefined;
    type: UpdateToolResponseBodyToolsResponse200Type;
    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>;
export declare const UpdateToolResponseBodyToolsResponseType: {
    readonly Http: "http";
};
export type UpdateToolResponseBodyToolsResponseType = ClosedEnum<typeof UpdateToolResponseBodyToolsResponseType>;
/**
 * 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 | undefined;
};
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 | undefined;
    /**
     * 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 | undefined;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * 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 | undefined;
    versionHash?: string | undefined;
    type: UpdateToolResponseBodyToolsResponseType;
    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>;
export declare const UpdateToolResponseBodyToolsType: {
    readonly JsonSchema: "json_schema";
};
export type UpdateToolResponseBodyToolsType = ClosedEnum<typeof UpdateToolResponseBodyToolsType>;
/**
 * 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 | undefined;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * 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 | undefined;
    versionHash?: string | undefined;
    type: UpdateToolResponseBodyToolsType;
    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>;
export declare const UpdateToolResponseBodyType: {
    readonly Function: "function";
};
export type UpdateToolResponseBodyType = ClosedEnum<typeof UpdateToolResponseBodyType>;
/**
 * 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 | undefined;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * 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 | undefined;
    versionHash?: string | undefined;
    type: UpdateToolResponseBodyType;
    function: UpdateToolResponseBodyFunction;
};
/**
 * Successfully updated the tool.
 */
export type UpdateToolResponseBody = UpdateToolResponseBodyFunctionTool | UpdateToolResponseBodyJSONSchemaTool | UpdateToolResponseBodyHTTPTool | UpdateToolResponseBodyMCPTool | UpdateToolResponseBodyCodeExecutionTool;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5Status$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5Status>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5Status$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5Status>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5Type>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5Type>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5CodeToolType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5CodeToolType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest5CodeToolType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest5CodeToolType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsParameters$inboundSchema: z.ZodType<UpdateToolRequestBodyToolsParameters, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyToolsParametersFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyToolsParameters, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyLanguage$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyLanguage>;
/** @internal */
export declare const UpdateToolRequestBodyLanguage$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyLanguage>;
/** @internal */
export declare const UpdateToolRequestBodyCodeTool$inboundSchema: z.ZodType<UpdateToolRequestBodyCodeTool, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyCodeToolFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyCodeTool, SDKValidationError>;
/** @internal */
export declare const UpdateCodeExecutionTool$inboundSchema: z.ZodType<UpdateCodeExecutionTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateCodeExecutionTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: string;
    code_tool?: UpdateToolRequestBodyCodeTool$Outbound | undefined;
};
/** @internal */
export declare const UpdateCodeExecutionTool$outboundSchema: z.ZodType<UpdateCodeExecutionTool$Outbound, z.ZodTypeDef, UpdateCodeExecutionTool>;
export declare function updateCodeExecutionToolToJSON(updateCodeExecutionTool: UpdateCodeExecutionTool): string;
export declare function updateCodeExecutionToolFromJSON(jsonString: string): SafeParseResult<UpdateCodeExecutionTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4Status$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4Status>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4Status$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4Status>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4Type>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4Type>;
/** @internal */
export declare const UpdateToolRequestBodyHeaders$inboundSchema: z.ZodType<UpdateToolRequestBodyHeaders, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyHeadersFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyHeaders, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4McpType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4McpType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest4McpType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest4McpType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsSchema$inboundSchema: z.ZodType<UpdateToolRequestBodyToolsSchema, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyToolsSchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyToolsSchema, SDKValidationError>;
/** @internal */
export declare const RequestBodyTools$inboundSchema: z.ZodType<RequestBodyTools, z.ZodTypeDef, unknown>;
/** @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;
export declare function requestBodyToolsFromJSON(jsonString: string): SafeParseResult<RequestBodyTools, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyConnectionType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyConnectionType>;
/** @internal */
export declare const UpdateToolRequestBodyConnectionType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyConnectionType>;
/** @internal */
export declare const UpdateToolRequestBodyMcp$inboundSchema: z.ZodType<UpdateToolRequestBodyMcp, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyMcpFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyMcp, SDKValidationError>;
/** @internal */
export declare const UpdateMCPTool$inboundSchema: z.ZodType<UpdateMCPTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateMCPTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: string;
    mcp?: UpdateToolRequestBodyMcp$Outbound | undefined;
};
/** @internal */
export declare const UpdateMCPTool$outboundSchema: z.ZodType<UpdateMCPTool$Outbound, z.ZodTypeDef, UpdateMCPTool>;
export declare function updateMCPToolToJSON(updateMCPTool: UpdateMCPTool): string;
export declare function updateMCPToolFromJSON(jsonString: string): SafeParseResult<UpdateMCPTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequestStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequestStatus>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequestStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequestStatus>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequestType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequestType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequestType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequestType>;
/** @internal */
export declare const UpdateToolRequestBodyMethod$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyMethod>;
/** @internal */
export declare const UpdateToolRequestBodyMethod$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyMethod>;
/** @internal */
export declare const UpdateToolHeaders2$inboundSchema: z.ZodType<UpdateToolHeaders2, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolHeaders2FromJSON(jsonString: string): SafeParseResult<UpdateToolHeaders2, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyToolsHeaders$inboundSchema: z.ZodType<UpdateToolRequestBodyToolsHeaders, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyToolsHeadersFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyToolsHeaders, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyBlueprint$inboundSchema: z.ZodType<UpdateToolRequestBodyBlueprint, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyBlueprintFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyBlueprint, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest3Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest3Type>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest3Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest3Type>;
/** @internal */
export declare const UpdateToolRequestBodyDefaultValue$inboundSchema: z.ZodType<UpdateToolRequestBodyDefaultValue, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyDefaultValueFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyDefaultValue, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyArguments$inboundSchema: z.ZodType<UpdateToolRequestBodyArguments, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyArgumentsFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyArguments, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyHttp$inboundSchema: z.ZodType<UpdateToolRequestBodyHttp, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyHttpFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyHttp, SDKValidationError>;
/** @internal */
export declare const UpdateHTTPTool$inboundSchema: z.ZodType<UpdateHTTPTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateHTTPTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: string;
    http?: UpdateToolRequestBodyHttp$Outbound | undefined;
};
/** @internal */
export declare const UpdateHTTPTool$outboundSchema: z.ZodType<UpdateHTTPTool$Outbound, z.ZodTypeDef, UpdateHTTPTool>;
export declare function updateHTTPToolToJSON(updateHTTPTool: UpdateHTTPTool): string;
export declare function updateHTTPToolFromJSON(jsonString: string): SafeParseResult<UpdateHTTPTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyToolsStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsStatus>;
/** @internal */
export declare const UpdateToolRequestBodyToolsStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsStatus>;
/** @internal */
export declare const UpdateToolRequestBodyToolsType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsType>;
/** @internal */
export declare const UpdateToolRequestBodySchema$inboundSchema: z.ZodType<UpdateToolRequestBodySchema, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodySchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodySchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyJsonSchema$inboundSchema: z.ZodType<UpdateToolRequestBodyJsonSchema, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyJsonSchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyJsonSchema, SDKValidationError>;
/** @internal */
export declare const UpdateJSONSchemaTool$inboundSchema: z.ZodType<UpdateJSONSchemaTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateJSONSchemaTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: string;
    json_schema?: UpdateToolRequestBodyJsonSchema$Outbound | undefined;
};
/** @internal */
export declare const UpdateJSONSchemaTool$outboundSchema: z.ZodType<UpdateJSONSchemaTool$Outbound, z.ZodTypeDef, UpdateJSONSchemaTool>;
export declare function updateJSONSchemaToolToJSON(updateJSONSchemaTool: UpdateJSONSchemaTool): string;
export declare function updateJSONSchemaToolFromJSON(jsonString: string): SafeParseResult<UpdateJSONSchemaTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyStatus>;
/** @internal */
export declare const UpdateToolRequestBodyStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyStatus>;
/** @internal */
export declare const UpdateToolRequestBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyType>;
/** @internal */
export declare const UpdateToolRequestBodyType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyType>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest1Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest1Type>;
/** @internal */
export declare const UpdateToolRequestBodyToolsRequest1Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolRequestBodyToolsRequest1Type>;
/** @internal */
export declare const UpdateToolRequestBodyParameters$inboundSchema: z.ZodType<UpdateToolRequestBodyParameters, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyParametersFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyParameters, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBodyFunction$inboundSchema: z.ZodType<UpdateToolRequestBodyFunction, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyFunctionFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBodyFunction, SDKValidationError>;
/** @internal */
export declare const UpdateFunctionTool$inboundSchema: z.ZodType<UpdateFunctionTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateFunctionTool$Outbound = {
    path?: string | undefined;
    key?: string | undefined;
    display_name?: string | undefined;
    description?: string | undefined;
    status: string;
    type: string;
    function?: UpdateToolRequestBodyFunction$Outbound | undefined;
};
/** @internal */
export declare const UpdateFunctionTool$outboundSchema: z.ZodType<UpdateFunctionTool$Outbound, z.ZodTypeDef, UpdateFunctionTool>;
export declare function updateFunctionToolToJSON(updateFunctionTool: UpdateFunctionTool): string;
export declare function updateFunctionToolFromJSON(jsonString: string): SafeParseResult<UpdateFunctionTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequestBody$inboundSchema: z.ZodType<UpdateToolRequestBody, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestBodyFromJSON(jsonString: string): SafeParseResult<UpdateToolRequestBody, SDKValidationError>;
/** @internal */
export declare const UpdateToolRequest$inboundSchema: z.ZodType<UpdateToolRequest, z.ZodTypeDef, unknown>;
/** @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;
export declare function updateToolRequestFromJSON(jsonString: string): SafeParseResult<UpdateToolRequest, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONType>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJSONType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJSONType>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson5Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson5Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson5Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson5Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsParameters$inboundSchema: z.ZodType<UpdateToolResponseBodyToolsParameters, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyToolsParameters$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const UpdateToolResponseBodyToolsParameters$outboundSchema: z.ZodType<UpdateToolResponseBodyToolsParameters$Outbound, z.ZodTypeDef, UpdateToolResponseBodyToolsParameters>;
export declare function updateToolResponseBodyToolsParametersToJSON(updateToolResponseBodyToolsParameters: UpdateToolResponseBodyToolsParameters): string;
export declare function updateToolResponseBodyToolsParametersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyToolsParameters, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyLanguage$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyLanguage>;
/** @internal */
export declare const UpdateToolResponseBodyLanguage$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyLanguage>;
/** @internal */
export declare const UpdateToolResponseBodyCodeTool$inboundSchema: z.ZodType<UpdateToolResponseBodyCodeTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyCodeTool$Outbound = {
    parameters?: UpdateToolResponseBodyToolsParameters$Outbound | undefined;
    language: string;
    code: string;
};
/** @internal */
export declare const UpdateToolResponseBodyCodeTool$outboundSchema: z.ZodType<UpdateToolResponseBodyCodeTool$Outbound, z.ZodTypeDef, UpdateToolResponseBodyCodeTool>;
export declare function updateToolResponseBodyCodeToolToJSON(updateToolResponseBodyCodeTool: UpdateToolResponseBodyCodeTool): string;
export declare function updateToolResponseBodyCodeToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyCodeTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyCodeExecutionTool$inboundSchema: z.ZodType<UpdateToolResponseBodyCodeExecutionTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyCodeExecutionTool$Outbound = {
    _id: string;
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    created_by_id?: string | undefined;
    updated_by_id?: string | undefined;
    project_id: string;
    workspace_id: string;
    created: string;
    updated: string;
    status: string;
    version_hash?: string | undefined;
    type: string;
    code_tool: UpdateToolResponseBodyCodeTool$Outbound;
};
/** @internal */
export declare const UpdateToolResponseBodyCodeExecutionTool$outboundSchema: z.ZodType<UpdateToolResponseBodyCodeExecutionTool$Outbound, z.ZodTypeDef, UpdateToolResponseBodyCodeExecutionTool>;
export declare function updateToolResponseBodyCodeExecutionToolToJSON(updateToolResponseBodyCodeExecutionTool: UpdateToolResponseBodyCodeExecutionTool): string;
export declare function updateToolResponseBodyCodeExecutionToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyCodeExecutionTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200Status$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200Status>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200Status$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200Status>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200Type>;
/** @internal */
export declare const UpdateToolResponseBodyHeaders$inboundSchema: z.ZodType<UpdateToolResponseBodyHeaders, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyHeaders$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const UpdateToolResponseBodyHeaders$outboundSchema: z.ZodType<UpdateToolResponseBodyHeaders$Outbound, z.ZodTypeDef, UpdateToolResponseBodyHeaders>;
export declare function updateToolResponseBodyHeadersToJSON(updateToolResponseBodyHeaders: UpdateToolResponseBodyHeaders): string;
export declare function updateToolResponseBodyHeadersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyHeaders, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson4Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson4Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsSchema$inboundSchema: z.ZodType<UpdateToolResponseBodyToolsSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyToolsSchema$Outbound = {
    type: string;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/** @internal */
export declare const UpdateToolResponseBodyToolsSchema$outboundSchema: z.ZodType<UpdateToolResponseBodyToolsSchema$Outbound, z.ZodTypeDef, UpdateToolResponseBodyToolsSchema>;
export declare function updateToolResponseBodyToolsSchemaToJSON(updateToolResponseBodyToolsSchema: UpdateToolResponseBodyToolsSchema): string;
export declare function updateToolResponseBodyToolsSchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyToolsSchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyTools$inboundSchema: z.ZodType<UpdateToolResponseBodyTools, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyTools$Outbound = {
    id: string;
    name: string;
    description?: string | undefined;
    schema: UpdateToolResponseBodyToolsSchema$Outbound;
};
/** @internal */
export declare const UpdateToolResponseBodyTools$outboundSchema: z.ZodType<UpdateToolResponseBodyTools$Outbound, z.ZodTypeDef, UpdateToolResponseBodyTools>;
export declare function updateToolResponseBodyToolsToJSON(updateToolResponseBodyTools: UpdateToolResponseBodyTools): string;
export declare function updateToolResponseBodyToolsFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyTools, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyConnectionType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyConnectionType>;
/** @internal */
export declare const UpdateToolResponseBodyConnectionType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyConnectionType>;
/** @internal */
export declare const UpdateToolResponseBodyMcp$inboundSchema: z.ZodType<UpdateToolResponseBodyMcp, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyMcp$Outbound = {
    server_url: string;
    headers?: {
        [k: string]: UpdateToolResponseBodyHeaders$Outbound;
    } | undefined;
    tools: Array<UpdateToolResponseBodyTools$Outbound>;
    connection_type: string;
};
/** @internal */
export declare const UpdateToolResponseBodyMcp$outboundSchema: z.ZodType<UpdateToolResponseBodyMcp$Outbound, z.ZodTypeDef, UpdateToolResponseBodyMcp>;
export declare function updateToolResponseBodyMcpToJSON(updateToolResponseBodyMcp: UpdateToolResponseBodyMcp): string;
export declare function updateToolResponseBodyMcpFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyMcp, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyMCPTool$inboundSchema: z.ZodType<UpdateToolResponseBodyMCPTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyMCPTool$Outbound = {
    _id: string;
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    created_by_id?: string | undefined;
    updated_by_id?: string | undefined;
    project_id: string;
    workspace_id: string;
    created: string;
    updated: string;
    status: string;
    version_hash?: string | undefined;
    type: string;
    mcp: UpdateToolResponseBodyMcp$Outbound;
};
/** @internal */
export declare const UpdateToolResponseBodyMCPTool$outboundSchema: z.ZodType<UpdateToolResponseBodyMCPTool$Outbound, z.ZodTypeDef, UpdateToolResponseBodyMCPTool>;
export declare function updateToolResponseBodyMCPToolToJSON(updateToolResponseBodyMCPTool: UpdateToolResponseBodyMCPTool): string;
export declare function updateToolResponseBodyMCPToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyMCPTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponseStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponseStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponseStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponseStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponseType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponseType>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponseType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponseType>;
/** @internal */
export declare const UpdateToolResponseBodyMethod$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyMethod>;
/** @internal */
export declare const UpdateToolResponseBodyMethod$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyMethod>;
/** @internal */
export declare const UpdateToolHeadersTools2$inboundSchema: z.ZodType<UpdateToolHeadersTools2, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolHeadersTools2$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const UpdateToolHeadersTools2$outboundSchema: z.ZodType<UpdateToolHeadersTools2$Outbound, z.ZodTypeDef, UpdateToolHeadersTools2>;
export declare function updateToolHeadersTools2ToJSON(updateToolHeadersTools2: UpdateToolHeadersTools2): string;
export declare function updateToolHeadersTools2FromJSON(jsonString: string): SafeParseResult<UpdateToolHeadersTools2, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsHeaders$inboundSchema: z.ZodType<UpdateToolResponseBodyToolsHeaders, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyToolsHeaders$Outbound = UpdateToolHeadersTools2$Outbound | string;
/** @internal */
export declare const UpdateToolResponseBodyToolsHeaders$outboundSchema: z.ZodType<UpdateToolResponseBodyToolsHeaders$Outbound, z.ZodTypeDef, UpdateToolResponseBodyToolsHeaders>;
export declare function updateToolResponseBodyToolsHeadersToJSON(updateToolResponseBodyToolsHeaders: UpdateToolResponseBodyToolsHeaders): string;
export declare function updateToolResponseBodyToolsHeadersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyToolsHeaders, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyBlueprint$inboundSchema: z.ZodType<UpdateToolResponseBodyBlueprint, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyBlueprint$Outbound = {
    url: string;
    method: string;
    headers?: {
        [k: string]: UpdateToolHeadersTools2$Outbound | string;
    } | undefined;
    body?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const UpdateToolResponseBodyBlueprint$outboundSchema: z.ZodType<UpdateToolResponseBodyBlueprint$Outbound, z.ZodTypeDef, UpdateToolResponseBodyBlueprint>;
export declare function updateToolResponseBodyBlueprintToJSON(updateToolResponseBodyBlueprint: UpdateToolResponseBodyBlueprint): string;
export declare function updateToolResponseBodyBlueprintFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyBlueprint, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson3Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson3Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/** @internal */
export declare const UpdateToolResponseBodyDefaultValue$inboundSchema: z.ZodType<UpdateToolResponseBodyDefaultValue, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyDefaultValue$Outbound = string | number | boolean;
/** @internal */
export declare const UpdateToolResponseBodyDefaultValue$outboundSchema: z.ZodType<UpdateToolResponseBodyDefaultValue$Outbound, z.ZodTypeDef, UpdateToolResponseBodyDefaultValue>;
export declare function updateToolResponseBodyDefaultValueToJSON(updateToolResponseBodyDefaultValue: UpdateToolResponseBodyDefaultValue): string;
export declare function updateToolResponseBodyDefaultValueFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyDefaultValue, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyArguments$inboundSchema: z.ZodType<UpdateToolResponseBodyArguments, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyArguments$Outbound = {
    type: string;
    description: string;
    send_to_model: boolean;
    default_value?: string | number | boolean | undefined;
};
/** @internal */
export declare const UpdateToolResponseBodyArguments$outboundSchema: z.ZodType<UpdateToolResponseBodyArguments$Outbound, z.ZodTypeDef, UpdateToolResponseBodyArguments>;
export declare function updateToolResponseBodyArgumentsToJSON(updateToolResponseBodyArguments: UpdateToolResponseBodyArguments): string;
export declare function updateToolResponseBodyArgumentsFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyArguments, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyHttp$inboundSchema: z.ZodType<UpdateToolResponseBodyHttp, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyHttp$Outbound = {
    blueprint: UpdateToolResponseBodyBlueprint$Outbound;
    arguments?: {
        [k: string]: UpdateToolResponseBodyArguments$Outbound;
    } | undefined;
};
/** @internal */
export declare const UpdateToolResponseBodyHttp$outboundSchema: z.ZodType<UpdateToolResponseBodyHttp$Outbound, z.ZodTypeDef, UpdateToolResponseBodyHttp>;
export declare function updateToolResponseBodyHttpToJSON(updateToolResponseBodyHttp: UpdateToolResponseBodyHttp): string;
export declare function updateToolResponseBodyHttpFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyHttp, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyHTTPTool$inboundSchema: z.ZodType<UpdateToolResponseBodyHTTPTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyHTTPTool$Outbound = {
    _id: string;
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    created_by_id?: string | undefined;
    updated_by_id?: string | undefined;
    project_id: string;
    workspace_id: string;
    created: string;
    updated: string;
    status: string;
    version_hash?: string | undefined;
    type: string;
    http: UpdateToolResponseBodyHttp$Outbound;
};
/** @internal */
export declare const UpdateToolResponseBodyHTTPTool$outboundSchema: z.ZodType<UpdateToolResponseBodyHTTPTool$Outbound, z.ZodTypeDef, UpdateToolResponseBodyHTTPTool>;
export declare function updateToolResponseBodyHTTPToolToJSON(updateToolResponseBodyHTTPTool: UpdateToolResponseBodyHTTPTool): string;
export declare function updateToolResponseBodyHTTPToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyHTTPTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyToolsStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsStatus>;
/** @internal */
export declare const UpdateToolResponseBodyToolsType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsType>;
/** @internal */
export declare const UpdateToolResponseBodyToolsType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsType>;
/** @internal */
export declare const UpdateToolResponseBodySchema$inboundSchema: z.ZodType<UpdateToolResponseBodySchema, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodySchema$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const UpdateToolResponseBodySchema$outboundSchema: z.ZodType<UpdateToolResponseBodySchema$Outbound, z.ZodTypeDef, UpdateToolResponseBodySchema>;
export declare function updateToolResponseBodySchemaToJSON(updateToolResponseBodySchema: UpdateToolResponseBodySchema): string;
export declare function updateToolResponseBodySchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodySchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyJsonSchema$inboundSchema: z.ZodType<UpdateToolResponseBodyJsonSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyJsonSchema$Outbound = {
    name: string;
    description: string;
    schema: UpdateToolResponseBodySchema$Outbound;
    strict?: boolean | undefined;
};
/** @internal */
export declare const UpdateToolResponseBodyJsonSchema$outboundSchema: z.ZodType<UpdateToolResponseBodyJsonSchema$Outbound, z.ZodTypeDef, UpdateToolResponseBodyJsonSchema>;
export declare function updateToolResponseBodyJsonSchemaToJSON(updateToolResponseBodyJsonSchema: UpdateToolResponseBodyJsonSchema): string;
export declare function updateToolResponseBodyJsonSchemaFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyJsonSchema, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyJSONSchemaTool$inboundSchema: z.ZodType<UpdateToolResponseBodyJSONSchemaTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyJSONSchemaTool$Outbound = {
    _id: string;
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    created_by_id?: string | undefined;
    updated_by_id?: string | undefined;
    project_id: string;
    workspace_id: string;
    created: string;
    updated: string;
    status: string;
    version_hash?: string | undefined;
    type: string;
    json_schema: UpdateToolResponseBodyJsonSchema$Outbound;
};
/** @internal */
export declare const UpdateToolResponseBodyJSONSchemaTool$outboundSchema: z.ZodType<UpdateToolResponseBodyJSONSchemaTool$Outbound, z.ZodTypeDef, UpdateToolResponseBodyJSONSchemaTool>;
export declare function updateToolResponseBodyJSONSchemaToolToJSON(updateToolResponseBodyJSONSchemaTool: UpdateToolResponseBodyJSONSchemaTool): string;
export declare function updateToolResponseBodyJSONSchemaToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyJSONSchemaTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyStatus>;
/** @internal */
export declare const UpdateToolResponseBodyStatus$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyStatus>;
/** @internal */
export declare const UpdateToolResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyType>;
/** @internal */
export declare const UpdateToolResponseBodyType$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyType>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson1Type$inboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson1Type>;
/** @internal */
export declare const UpdateToolResponseBodyToolsResponse200ApplicationJson1Type$outboundSchema: z.ZodNativeEnum<typeof UpdateToolResponseBodyToolsResponse200ApplicationJson1Type>;
/** @internal */
export declare const UpdateToolResponseBodyParameters$inboundSchema: z.ZodType<UpdateToolResponseBodyParameters, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyParameters$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const UpdateToolResponseBodyParameters$outboundSchema: z.ZodType<UpdateToolResponseBodyParameters$Outbound, z.ZodTypeDef, UpdateToolResponseBodyParameters>;
export declare function updateToolResponseBodyParametersToJSON(updateToolResponseBodyParameters: UpdateToolResponseBodyParameters): string;
export declare function updateToolResponseBodyParametersFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyParameters, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyFunction$inboundSchema: z.ZodType<UpdateToolResponseBodyFunction, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyFunction$Outbound = {
    name: string;
    description?: string | undefined;
    strict?: boolean | undefined;
    parameters?: UpdateToolResponseBodyParameters$Outbound | undefined;
};
/** @internal */
export declare const UpdateToolResponseBodyFunction$outboundSchema: z.ZodType<UpdateToolResponseBodyFunction$Outbound, z.ZodTypeDef, UpdateToolResponseBodyFunction>;
export declare function updateToolResponseBodyFunctionToJSON(updateToolResponseBodyFunction: UpdateToolResponseBodyFunction): string;
export declare function updateToolResponseBodyFunctionFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyFunction, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBodyFunctionTool$inboundSchema: z.ZodType<UpdateToolResponseBodyFunctionTool, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBodyFunctionTool$Outbound = {
    _id: string;
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    created_by_id?: string | undefined;
    updated_by_id?: string | undefined;
    project_id: string;
    workspace_id: string;
    created: string;
    updated: string;
    status: string;
    version_hash?: string | undefined;
    type: string;
    function: UpdateToolResponseBodyFunction$Outbound;
};
/** @internal */
export declare const UpdateToolResponseBodyFunctionTool$outboundSchema: z.ZodType<UpdateToolResponseBodyFunctionTool$Outbound, z.ZodTypeDef, UpdateToolResponseBodyFunctionTool>;
export declare function updateToolResponseBodyFunctionToolToJSON(updateToolResponseBodyFunctionTool: UpdateToolResponseBodyFunctionTool): string;
export declare function updateToolResponseBodyFunctionToolFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBodyFunctionTool, SDKValidationError>;
/** @internal */
export declare const UpdateToolResponseBody$inboundSchema: z.ZodType<UpdateToolResponseBody, z.ZodTypeDef, unknown>;
/** @internal */
export type UpdateToolResponseBody$Outbound = UpdateToolResponseBodyFunctionTool$Outbound | UpdateToolResponseBodyJSONSchemaTool$Outbound | UpdateToolResponseBodyHTTPTool$Outbound | UpdateToolResponseBodyMCPTool$Outbound | UpdateToolResponseBodyCodeExecutionTool$Outbound;
/** @internal */
export declare const UpdateToolResponseBody$outboundSchema: z.ZodType<UpdateToolResponseBody$Outbound, z.ZodTypeDef, UpdateToolResponseBody>;
export declare function updateToolResponseBodyToJSON(updateToolResponseBody: UpdateToolResponseBody): string;
export declare function updateToolResponseBodyFromJSON(jsonString: string): SafeParseResult<UpdateToolResponseBody, SDKValidationError>;
//# sourceMappingURL=updatetool.d.ts.map