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 CreateToolRequestBodyToolsRequestStatus: {
    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 CreateToolRequestBodyToolsRequestStatus = ClosedEnum<typeof CreateToolRequestBodyToolsRequestStatus>;
/**
 * The type must be "object"
 */
export declare const CreateToolRequestBodyToolsRequest5CodeToolType: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type CreateToolRequestBodyToolsRequest5CodeToolType = ClosedEnum<typeof CreateToolRequestBodyToolsRequest5CodeToolType>;
/**
 * 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 CreateToolRequestBodyParameters = {
    /**
     * The type must be "object"
     */
    type: CreateToolRequestBodyToolsRequest5CodeToolType;
    /**
     * 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 RequestBodyLanguage: {
    readonly Python: "python";
};
export type RequestBodyLanguage = ClosedEnum<typeof RequestBodyLanguage>;
export type RequestBodyCodeTool = {
    /**
     * 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?: CreateToolRequestBodyParameters | undefined;
    language: RequestBodyLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
/**
 * Executes code snippets in a sandboxed environment, currently supporting Python.
 */
export type RequestBodyCodeExecutionTool = {
    /**
     * 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 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?: CreateToolRequestBodyToolsRequestStatus | undefined;
    type: "code";
    codeTool: RequestBodyCodeTool;
};
/**
 * 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 CreateToolRequestBodyToolsStatus: {
    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 CreateToolRequestBodyToolsStatus = ClosedEnum<typeof CreateToolRequestBodyToolsStatus>;
export type RequestBodyHeaders = {
    value: string;
    encrypted?: boolean | undefined;
};
/**
 * The connection type used by the MCP server
 */
export declare const RequestBodyConnectionType: {
    readonly Http: "http";
    readonly Sse: "sse";
};
/**
 * The connection type used by the MCP server
 */
export type RequestBodyConnectionType = ClosedEnum<typeof RequestBodyConnectionType>;
export type RequestBodyMcp = {
    /**
     * The MCP server URL (cached for execution)
     */
    serverUrl: string;
    /**
     * HTTP headers for MCP server requests with encryption support
     */
    headers?: {
        [k: string]: RequestBodyHeaders;
    } | undefined;
    /**
     * The connection type used by the MCP server
     */
    connectionType: RequestBodyConnectionType;
};
/**
 * A tool from a Model Context Protocol (MCP) server that provides standardized access to external capabilities.
 */
export type RequestBodyMCPTool = {
    /**
     * 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 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?: CreateToolRequestBodyToolsStatus | undefined;
    type: "mcp";
    mcp: RequestBodyMcp;
};
/**
 * 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 CreateToolRequestBodyStatus: {
    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 CreateToolRequestBodyStatus = ClosedEnum<typeof CreateToolRequestBodyStatus>;
/**
 * The HTTP method to use.
 */
export declare const CreateToolRequestBodyMethod: {
    readonly Get: "GET";
    readonly Post: "POST";
    readonly Put: "PUT";
    readonly Delete: "DELETE";
};
/**
 * The HTTP method to use.
 */
export type CreateToolRequestBodyMethod = ClosedEnum<typeof CreateToolRequestBodyMethod>;
export type CreateToolHeaders2 = {
    value: string;
    encrypted?: boolean | undefined;
};
export type CreateToolRequestBodyHeaders = CreateToolHeaders2 | 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 RequestBodyBlueprint = {
    /**
     * The URL to send the request to.
     */
    url: string;
    /**
     * The HTTP method to use.
     */
    method: CreateToolRequestBodyMethod;
    /**
     * The headers to send with the request. Can be a string value or an object with value and encrypted properties.
     */
    headers?: {
        [k: string]: CreateToolHeaders2 | string;
    } | undefined;
    /**
     * The body to send with the request.
     */
    body?: {
        [k: string]: any;
    } | undefined;
};
/**
 * The type of the argument.
 */
export declare const CreateToolRequestBodyToolsRequest3Type: {
    readonly String: "string";
    readonly Number: "number";
    readonly Boolean: "boolean";
};
/**
 * The type of the argument.
 */
export type CreateToolRequestBodyToolsRequest3Type = ClosedEnum<typeof CreateToolRequestBodyToolsRequest3Type>;
/**
 * The default value of the argument.
 */
export type RequestBodyDefaultValue = string | number | boolean;
export type RequestBodyArguments = {
    /**
     * The type of the argument.
     */
    type: CreateToolRequestBodyToolsRequest3Type;
    /**
     * 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 CreateToolRequestBodyHttp = {
    /**
     * 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: RequestBodyBlueprint;
    /**
     * The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field.
     */
    arguments?: {
        [k: string]: RequestBodyArguments;
    } | undefined;
};
/**
 * Executes HTTP requests to interact with external APIs and web services using customizable blueprints.
 */
export type RequestBodyHTTPTool = {
    /**
     * 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 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?: CreateToolRequestBodyStatus | undefined;
    type: "http";
    http: CreateToolRequestBodyHttp;
};
/**
 * 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 RequestBodyStatus: {
    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 RequestBodyStatus = ClosedEnum<typeof RequestBodyStatus>;
/**
 * 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 RequestBodySchema = {
    /**
     * 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 RequestBodyJsonSchema = {
    /**
     * 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: RequestBodySchema;
    /**
     * 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 RequestBodyJSONSchemaTool = {
    /**
     * 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 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?: RequestBodyStatus | undefined;
    type: "json_schema";
    jsonSchema: RequestBodyJsonSchema;
};
/**
 * 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 CreateToolRequestBodyToolsRequest1Status: {
    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 CreateToolRequestBodyToolsRequest1Status = ClosedEnum<typeof CreateToolRequestBodyToolsRequest1Status>;
/**
 * The type must be "object"
 */
export declare const CreateToolRequestBodyToolsRequest1Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type CreateToolRequestBodyToolsRequest1Type = ClosedEnum<typeof CreateToolRequestBodyToolsRequest1Type>;
/**
 * 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 RequestBodyParameters = {
    /**
     * The type must be "object"
     */
    type: CreateToolRequestBodyToolsRequest1Type;
    /**
     * 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 RequestBodyFunction = {
    /**
     * 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?: RequestBodyParameters | undefined;
};
/**
 * A custom function tool that allows the model to call predefined functions with structured parameters.
 */
export type RequestBodyFunctionTool = {
    /**
     * 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 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?: CreateToolRequestBodyToolsRequest1Status | undefined;
    type: "function";
    function: RequestBodyFunction;
};
/**
 * The tool to create
 */
export type CreateToolRequestBody = RequestBodyFunctionTool | RequestBodyJSONSchemaTool | RequestBodyHTTPTool | RequestBodyMCPTool | RequestBodyCodeExecutionTool;
/**
 * 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 CreateToolResponseBodyToolsResponse200Status: {
    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 CreateToolResponseBodyToolsResponse200Status = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200Status>;
/**
 * The type must be "object"
 */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson5Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type CreateToolResponseBodyToolsResponse200ApplicationJson5Type = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson5Type>;
/**
 * 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 CreateToolResponseBodyParameters = {
    /**
     * The type must be "object"
     */
    type: CreateToolResponseBodyToolsResponse200ApplicationJson5Type;
    /**
     * 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 ResponseBodyLanguage: {
    readonly Python: "python";
};
export type ResponseBodyLanguage = ClosedEnum<typeof ResponseBodyLanguage>;
export type ResponseBodyCodeTool = {
    /**
     * 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?: CreateToolResponseBodyParameters | undefined;
    language: ResponseBodyLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
/**
 * Executes code snippets in a sandboxed environment, currently supporting Python.
 */
export type ResponseBodyCodeExecutionTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: CreateToolResponseBodyToolsResponse200Status;
    versionHash?: string | undefined;
    type: "code";
    codeTool: ResponseBodyCodeTool;
};
/**
 * 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 CreateToolResponseBodyToolsResponseStatus: {
    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 CreateToolResponseBodyToolsResponseStatus = ClosedEnum<typeof CreateToolResponseBodyToolsResponseStatus>;
export type ResponseBodyHeaders = {
    value: string;
    encrypted: boolean;
};
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson4Type: {
    readonly Object: "object";
};
export type CreateToolResponseBodyToolsResponse200ApplicationJson4Type = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson4Type>;
export type CreateToolResponseBodySchema = {
    type: CreateToolResponseBodyToolsResponse200ApplicationJson4Type;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
export type ResponseBodyTools = {
    id: string;
    name: string;
    description?: string | undefined;
    schema: CreateToolResponseBodySchema;
};
/**
 * The connection type used by the MCP server
 */
export declare const ResponseBodyConnectionType: {
    readonly Http: "http";
    readonly Sse: "sse";
};
/**
 * The connection type used by the MCP server
 */
export type ResponseBodyConnectionType = ClosedEnum<typeof ResponseBodyConnectionType>;
export type ResponseBodyMcp = {
    /**
     * The MCP server URL (cached for execution)
     */
    serverUrl: string;
    /**
     * HTTP headers for MCP server requests with encryption support
     */
    headers?: {
        [k: string]: ResponseBodyHeaders;
    } | undefined;
    /**
     * Array of tools available from the MCP server
     */
    tools: Array<ResponseBodyTools>;
    /**
     * The connection type used by the MCP server
     */
    connectionType: ResponseBodyConnectionType;
};
/**
 * A tool from a Model Context Protocol (MCP) server that provides standardized access to external capabilities.
 */
export type ResponseBodyMCPTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: CreateToolResponseBodyToolsResponseStatus;
    versionHash?: string | undefined;
    type: "mcp";
    mcp: ResponseBodyMcp;
};
/**
 * 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 CreateToolResponseBodyToolsStatus: {
    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 CreateToolResponseBodyToolsStatus = ClosedEnum<typeof CreateToolResponseBodyToolsStatus>;
/**
 * The HTTP method to use.
 */
export declare const CreateToolResponseBodyMethod: {
    readonly Get: "GET";
    readonly Post: "POST";
    readonly Put: "PUT";
    readonly Delete: "DELETE";
};
/**
 * The HTTP method to use.
 */
export type CreateToolResponseBodyMethod = ClosedEnum<typeof CreateToolResponseBodyMethod>;
export type CreateToolHeadersTools2 = {
    value: string;
    encrypted: boolean;
};
export type CreateToolResponseBodyHeaders = CreateToolHeadersTools2 | 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 ResponseBodyBlueprint = {
    /**
     * The URL to send the request to.
     */
    url: string;
    /**
     * The HTTP method to use.
     */
    method: CreateToolResponseBodyMethod;
    /**
     * The headers to send with the request. Can be a string value or an object with value and encrypted properties.
     */
    headers?: {
        [k: string]: CreateToolHeadersTools2 | string;
    } | undefined;
    /**
     * The body to send with the request.
     */
    body?: {
        [k: string]: any;
    } | undefined;
};
/**
 * The type of the argument.
 */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson3Type: {
    readonly String: "string";
    readonly Number: "number";
    readonly Boolean: "boolean";
};
/**
 * The type of the argument.
 */
export type CreateToolResponseBodyToolsResponse200ApplicationJson3Type = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/**
 * The default value of the argument.
 */
export type ResponseBodyDefaultValue = string | number | boolean;
export type ResponseBodyArguments = {
    /**
     * The type of the argument.
     */
    type: CreateToolResponseBodyToolsResponse200ApplicationJson3Type;
    /**
     * A description of the argument.
     */
    description: string;
    /**
     * Whether to send the argument to the model. If set to false, the argument will not be sent to the model and needs to be provided by the user or it will be left blank.
     */
    sendToModel: boolean;
    /**
     * The default value of the argument.
     */
    defaultValue?: string | number | boolean | undefined;
};
export type CreateToolResponseBodyHttp = {
    /**
     * 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: ResponseBodyBlueprint;
    /**
     * The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field.
     */
    arguments?: {
        [k: string]: ResponseBodyArguments;
    } | undefined;
};
/**
 * Executes HTTP requests to interact with external APIs and web services using customizable blueprints.
 */
export type ResponseBodyHTTPTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: CreateToolResponseBodyToolsStatus;
    versionHash?: string | undefined;
    type: "http";
    http: CreateToolResponseBodyHttp;
};
/**
 * 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 CreateToolResponseBodyStatus: {
    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 CreateToolResponseBodyStatus = ClosedEnum<typeof CreateToolResponseBodyStatus>;
/**
 * 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 ResponseBodySchema = {
    /**
     * 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 ResponseBodyJsonSchema = {
    /**
     * 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: ResponseBodySchema;
    /**
     * 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 ResponseBodyJSONSchemaTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: CreateToolResponseBodyStatus;
    versionHash?: string | undefined;
    type: "json_schema";
    jsonSchema: ResponseBodyJsonSchema;
};
/**
 * 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 ResponseBodyStatus: {
    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 ResponseBodyStatus = ClosedEnum<typeof ResponseBodyStatus>;
/**
 * The type must be "object"
 */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson1Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type CreateToolResponseBodyToolsResponse200ApplicationJson1Type = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson1Type>;
/**
 * 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 ResponseBodyParameters = {
    /**
     * The type must be "object"
     */
    type: CreateToolResponseBodyToolsResponse200ApplicationJson1Type;
    /**
     * 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 CreateToolResponseBodyFunction = {
    /**
     * 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?: ResponseBodyParameters | undefined;
};
/**
 * A custom function tool that allows the model to call predefined functions with structured parameters.
 */
export type ResponseBodyFunctionTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: ResponseBodyStatus;
    versionHash?: string | undefined;
    type: "function";
    function: CreateToolResponseBodyFunction;
};
/**
 * Successfully created the tool.
 */
export type CreateToolResponseBody = ResponseBodyFunctionTool | ResponseBodyJSONSchemaTool | ResponseBodyHTTPTool | ResponseBodyMCPTool | ResponseBodyCodeExecutionTool;
/** @internal */
export declare const CreateToolRequestBodyToolsRequestStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequestStatus>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest5CodeToolType$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest5CodeToolType>;
/** @internal */
export type CreateToolRequestBodyParameters$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const CreateToolRequestBodyParameters$outboundSchema: z.ZodType<CreateToolRequestBodyParameters$Outbound, z.ZodTypeDef, CreateToolRequestBodyParameters>;
export declare function createToolRequestBodyParametersToJSON(createToolRequestBodyParameters: CreateToolRequestBodyParameters): string;
/** @internal */
export declare const RequestBodyLanguage$outboundSchema: z.ZodNativeEnum<typeof RequestBodyLanguage>;
/** @internal */
export type RequestBodyCodeTool$Outbound = {
    parameters?: CreateToolRequestBodyParameters$Outbound | undefined;
    language: string;
    code: string;
};
/** @internal */
export declare const RequestBodyCodeTool$outboundSchema: z.ZodType<RequestBodyCodeTool$Outbound, z.ZodTypeDef, RequestBodyCodeTool>;
export declare function requestBodyCodeToolToJSON(requestBodyCodeTool: RequestBodyCodeTool): string;
/** @internal */
export type RequestBodyCodeExecutionTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: "code";
    code_tool: RequestBodyCodeTool$Outbound;
};
/** @internal */
export declare const RequestBodyCodeExecutionTool$outboundSchema: z.ZodType<RequestBodyCodeExecutionTool$Outbound, z.ZodTypeDef, RequestBodyCodeExecutionTool>;
export declare function requestBodyCodeExecutionToolToJSON(requestBodyCodeExecutionTool: RequestBodyCodeExecutionTool): string;
/** @internal */
export declare const CreateToolRequestBodyToolsStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsStatus>;
/** @internal */
export type RequestBodyHeaders$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const RequestBodyHeaders$outboundSchema: z.ZodType<RequestBodyHeaders$Outbound, z.ZodTypeDef, RequestBodyHeaders>;
export declare function requestBodyHeadersToJSON(requestBodyHeaders: RequestBodyHeaders): string;
/** @internal */
export declare const RequestBodyConnectionType$outboundSchema: z.ZodNativeEnum<typeof RequestBodyConnectionType>;
/** @internal */
export type RequestBodyMcp$Outbound = {
    server_url: string;
    headers?: {
        [k: string]: RequestBodyHeaders$Outbound;
    } | undefined;
    connection_type: string;
};
/** @internal */
export declare const RequestBodyMcp$outboundSchema: z.ZodType<RequestBodyMcp$Outbound, z.ZodTypeDef, RequestBodyMcp>;
export declare function requestBodyMcpToJSON(requestBodyMcp: RequestBodyMcp): string;
/** @internal */
export type RequestBodyMCPTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: "mcp";
    mcp: RequestBodyMcp$Outbound;
};
/** @internal */
export declare const RequestBodyMCPTool$outboundSchema: z.ZodType<RequestBodyMCPTool$Outbound, z.ZodTypeDef, RequestBodyMCPTool>;
export declare function requestBodyMCPToolToJSON(requestBodyMCPTool: RequestBodyMCPTool): string;
/** @internal */
export declare const CreateToolRequestBodyStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyStatus>;
/** @internal */
export declare const CreateToolRequestBodyMethod$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyMethod>;
/** @internal */
export type CreateToolHeaders2$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const CreateToolHeaders2$outboundSchema: z.ZodType<CreateToolHeaders2$Outbound, z.ZodTypeDef, CreateToolHeaders2>;
export declare function createToolHeaders2ToJSON(createToolHeaders2: CreateToolHeaders2): string;
/** @internal */
export type CreateToolRequestBodyHeaders$Outbound = CreateToolHeaders2$Outbound | string;
/** @internal */
export declare const CreateToolRequestBodyHeaders$outboundSchema: z.ZodType<CreateToolRequestBodyHeaders$Outbound, z.ZodTypeDef, CreateToolRequestBodyHeaders>;
export declare function createToolRequestBodyHeadersToJSON(createToolRequestBodyHeaders: CreateToolRequestBodyHeaders): string;
/** @internal */
export type RequestBodyBlueprint$Outbound = {
    url: string;
    method: string;
    headers?: {
        [k: string]: CreateToolHeaders2$Outbound | string;
    } | undefined;
    body?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const RequestBodyBlueprint$outboundSchema: z.ZodType<RequestBodyBlueprint$Outbound, z.ZodTypeDef, RequestBodyBlueprint>;
export declare function requestBodyBlueprintToJSON(requestBodyBlueprint: RequestBodyBlueprint): string;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest3Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest3Type>;
/** @internal */
export type RequestBodyDefaultValue$Outbound = string | number | boolean;
/** @internal */
export declare const RequestBodyDefaultValue$outboundSchema: z.ZodType<RequestBodyDefaultValue$Outbound, z.ZodTypeDef, RequestBodyDefaultValue>;
export declare function requestBodyDefaultValueToJSON(requestBodyDefaultValue: RequestBodyDefaultValue): string;
/** @internal */
export type RequestBodyArguments$Outbound = {
    type: string;
    description: string;
    send_to_model: boolean;
    default_value?: string | number | boolean | undefined;
};
/** @internal */
export declare const RequestBodyArguments$outboundSchema: z.ZodType<RequestBodyArguments$Outbound, z.ZodTypeDef, RequestBodyArguments>;
export declare function requestBodyArgumentsToJSON(requestBodyArguments: RequestBodyArguments): string;
/** @internal */
export type CreateToolRequestBodyHttp$Outbound = {
    blueprint: RequestBodyBlueprint$Outbound;
    arguments?: {
        [k: string]: RequestBodyArguments$Outbound;
    } | undefined;
};
/** @internal */
export declare const CreateToolRequestBodyHttp$outboundSchema: z.ZodType<CreateToolRequestBodyHttp$Outbound, z.ZodTypeDef, CreateToolRequestBodyHttp>;
export declare function createToolRequestBodyHttpToJSON(createToolRequestBodyHttp: CreateToolRequestBodyHttp): string;
/** @internal */
export type RequestBodyHTTPTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: "http";
    http: CreateToolRequestBodyHttp$Outbound;
};
/** @internal */
export declare const RequestBodyHTTPTool$outboundSchema: z.ZodType<RequestBodyHTTPTool$Outbound, z.ZodTypeDef, RequestBodyHTTPTool>;
export declare function requestBodyHTTPToolToJSON(requestBodyHTTPTool: RequestBodyHTTPTool): string;
/** @internal */
export declare const RequestBodyStatus$outboundSchema: z.ZodNativeEnum<typeof RequestBodyStatus>;
/** @internal */
export type RequestBodySchema$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const RequestBodySchema$outboundSchema: z.ZodType<RequestBodySchema$Outbound, z.ZodTypeDef, RequestBodySchema>;
export declare function requestBodySchemaToJSON(requestBodySchema: RequestBodySchema): string;
/** @internal */
export type RequestBodyJsonSchema$Outbound = {
    name: string;
    description: string;
    schema: RequestBodySchema$Outbound;
    strict?: boolean | undefined;
};
/** @internal */
export declare const RequestBodyJsonSchema$outboundSchema: z.ZodType<RequestBodyJsonSchema$Outbound, z.ZodTypeDef, RequestBodyJsonSchema>;
export declare function requestBodyJsonSchemaToJSON(requestBodyJsonSchema: RequestBodyJsonSchema): string;
/** @internal */
export type RequestBodyJSONSchemaTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: "json_schema";
    json_schema: RequestBodyJsonSchema$Outbound;
};
/** @internal */
export declare const RequestBodyJSONSchemaTool$outboundSchema: z.ZodType<RequestBodyJSONSchemaTool$Outbound, z.ZodTypeDef, RequestBodyJSONSchemaTool>;
export declare function requestBodyJSONSchemaToolToJSON(requestBodyJSONSchemaTool: RequestBodyJSONSchemaTool): string;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest1Status$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest1Status>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest1Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest1Type>;
/** @internal */
export type RequestBodyParameters$Outbound = {
    type: string;
    properties: {
        [k: string]: any;
    };
    required: Array<string>;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const RequestBodyParameters$outboundSchema: z.ZodType<RequestBodyParameters$Outbound, z.ZodTypeDef, RequestBodyParameters>;
export declare function requestBodyParametersToJSON(requestBodyParameters: RequestBodyParameters): string;
/** @internal */
export type RequestBodyFunction$Outbound = {
    name: string;
    description?: string | undefined;
    strict?: boolean | undefined;
    parameters?: RequestBodyParameters$Outbound | undefined;
};
/** @internal */
export declare const RequestBodyFunction$outboundSchema: z.ZodType<RequestBodyFunction$Outbound, z.ZodTypeDef, RequestBodyFunction>;
export declare function requestBodyFunctionToJSON(requestBodyFunction: RequestBodyFunction): string;
/** @internal */
export type RequestBodyFunctionTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: "function";
    function: RequestBodyFunction$Outbound;
};
/** @internal */
export declare const RequestBodyFunctionTool$outboundSchema: z.ZodType<RequestBodyFunctionTool$Outbound, z.ZodTypeDef, RequestBodyFunctionTool>;
export declare function requestBodyFunctionToolToJSON(requestBodyFunctionTool: RequestBodyFunctionTool): string;
/** @internal */
export type CreateToolRequestBody$Outbound = RequestBodyFunctionTool$Outbound | RequestBodyJSONSchemaTool$Outbound | RequestBodyHTTPTool$Outbound | RequestBodyMCPTool$Outbound | RequestBodyCodeExecutionTool$Outbound;
/** @internal */
export declare const CreateToolRequestBody$outboundSchema: z.ZodType<CreateToolRequestBody$Outbound, z.ZodTypeDef, CreateToolRequestBody>;
export declare function createToolRequestBodyToJSON(createToolRequestBody: CreateToolRequestBody): string;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200Status$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200Status>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson5Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson5Type>;
/** @internal */
export declare const CreateToolResponseBodyParameters$inboundSchema: z.ZodType<CreateToolResponseBodyParameters, z.ZodTypeDef, unknown>;
export declare function createToolResponseBodyParametersFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodyParameters, SDKValidationError>;
/** @internal */
export declare const ResponseBodyLanguage$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyLanguage>;
/** @internal */
export declare const ResponseBodyCodeTool$inboundSchema: z.ZodType<ResponseBodyCodeTool, z.ZodTypeDef, unknown>;
export declare function responseBodyCodeToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyCodeTool, SDKValidationError>;
/** @internal */
export declare const ResponseBodyCodeExecutionTool$inboundSchema: z.ZodType<ResponseBodyCodeExecutionTool, z.ZodTypeDef, unknown>;
export declare function responseBodyCodeExecutionToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyCodeExecutionTool, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponseStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponseStatus>;
/** @internal */
export declare const ResponseBodyHeaders$inboundSchema: z.ZodType<ResponseBodyHeaders, z.ZodTypeDef, unknown>;
export declare function responseBodyHeadersFromJSON(jsonString: string): SafeParseResult<ResponseBodyHeaders, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson4Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/** @internal */
export declare const CreateToolResponseBodySchema$inboundSchema: z.ZodType<CreateToolResponseBodySchema, z.ZodTypeDef, unknown>;
export declare function createToolResponseBodySchemaFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodySchema, SDKValidationError>;
/** @internal */
export declare const ResponseBodyTools$inboundSchema: z.ZodType<ResponseBodyTools, z.ZodTypeDef, unknown>;
export declare function responseBodyToolsFromJSON(jsonString: string): SafeParseResult<ResponseBodyTools, SDKValidationError>;
/** @internal */
export declare const ResponseBodyConnectionType$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyConnectionType>;
/** @internal */
export declare const ResponseBodyMcp$inboundSchema: z.ZodType<ResponseBodyMcp, z.ZodTypeDef, unknown>;
export declare function responseBodyMcpFromJSON(jsonString: string): SafeParseResult<ResponseBodyMcp, SDKValidationError>;
/** @internal */
export declare const ResponseBodyMCPTool$inboundSchema: z.ZodType<ResponseBodyMCPTool, z.ZodTypeDef, unknown>;
export declare function responseBodyMCPToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyMCPTool, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsStatus>;
/** @internal */
export declare const CreateToolResponseBodyMethod$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyMethod>;
/** @internal */
export declare const CreateToolHeadersTools2$inboundSchema: z.ZodType<CreateToolHeadersTools2, z.ZodTypeDef, unknown>;
export declare function createToolHeadersTools2FromJSON(jsonString: string): SafeParseResult<CreateToolHeadersTools2, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyHeaders$inboundSchema: z.ZodType<CreateToolResponseBodyHeaders, z.ZodTypeDef, unknown>;
export declare function createToolResponseBodyHeadersFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodyHeaders, SDKValidationError>;
/** @internal */
export declare const ResponseBodyBlueprint$inboundSchema: z.ZodType<ResponseBodyBlueprint, z.ZodTypeDef, unknown>;
export declare function responseBodyBlueprintFromJSON(jsonString: string): SafeParseResult<ResponseBodyBlueprint, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson3Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/** @internal */
export declare const ResponseBodyDefaultValue$inboundSchema: z.ZodType<ResponseBodyDefaultValue, z.ZodTypeDef, unknown>;
export declare function responseBodyDefaultValueFromJSON(jsonString: string): SafeParseResult<ResponseBodyDefaultValue, SDKValidationError>;
/** @internal */
export declare const ResponseBodyArguments$inboundSchema: z.ZodType<ResponseBodyArguments, z.ZodTypeDef, unknown>;
export declare function responseBodyArgumentsFromJSON(jsonString: string): SafeParseResult<ResponseBodyArguments, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyHttp$inboundSchema: z.ZodType<CreateToolResponseBodyHttp, z.ZodTypeDef, unknown>;
export declare function createToolResponseBodyHttpFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodyHttp, SDKValidationError>;
/** @internal */
export declare const ResponseBodyHTTPTool$inboundSchema: z.ZodType<ResponseBodyHTTPTool, z.ZodTypeDef, unknown>;
export declare function responseBodyHTTPToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyHTTPTool, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyStatus>;
/** @internal */
export declare const ResponseBodySchema$inboundSchema: z.ZodType<ResponseBodySchema, z.ZodTypeDef, unknown>;
export declare function responseBodySchemaFromJSON(jsonString: string): SafeParseResult<ResponseBodySchema, SDKValidationError>;
/** @internal */
export declare const ResponseBodyJsonSchema$inboundSchema: z.ZodType<ResponseBodyJsonSchema, z.ZodTypeDef, unknown>;
export declare function responseBodyJsonSchemaFromJSON(jsonString: string): SafeParseResult<ResponseBodyJsonSchema, SDKValidationError>;
/** @internal */
export declare const ResponseBodyJSONSchemaTool$inboundSchema: z.ZodType<ResponseBodyJSONSchemaTool, z.ZodTypeDef, unknown>;
export declare function responseBodyJSONSchemaToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyJSONSchemaTool, SDKValidationError>;
/** @internal */
export declare const ResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyStatus>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson1Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson1Type>;
/** @internal */
export declare const ResponseBodyParameters$inboundSchema: z.ZodType<ResponseBodyParameters, z.ZodTypeDef, unknown>;
export declare function responseBodyParametersFromJSON(jsonString: string): SafeParseResult<ResponseBodyParameters, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyFunction$inboundSchema: z.ZodType<CreateToolResponseBodyFunction, z.ZodTypeDef, unknown>;
export declare function createToolResponseBodyFunctionFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodyFunction, SDKValidationError>;
/** @internal */
export declare const ResponseBodyFunctionTool$inboundSchema: z.ZodType<ResponseBodyFunctionTool, z.ZodTypeDef, unknown>;
export declare function responseBodyFunctionToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyFunctionTool, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBody$inboundSchema: z.ZodType<CreateToolResponseBody, z.ZodTypeDef, unknown>;
export declare function createToolResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBody, SDKValidationError>;
//# sourceMappingURL=createtool.d.ts.map