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 CreateToolRequestBodyToolsRequest5Status: {
    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 CreateToolRequestBodyToolsRequest5Status = ClosedEnum<typeof CreateToolRequestBodyToolsRequest5Status>;
export declare const CreateToolRequestBodyToolsRequest5Type: {
    readonly Code: "code";
};
export type CreateToolRequestBodyToolsRequest5Type = ClosedEnum<typeof CreateToolRequestBodyToolsRequest5Type>;
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?: {
        [k: string]: any;
    } | 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?: CreateToolRequestBodyToolsRequest5Status | undefined;
    type: CreateToolRequestBodyToolsRequest5Type;
    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 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>;
export declare const CreateToolRequestBodyToolsRequest4Type: {
    readonly Mcp: "mcp";
};
export type CreateToolRequestBodyToolsRequest4Type = ClosedEnum<typeof CreateToolRequestBodyToolsRequest4Type>;
export type Headers = {
    value: string;
    encrypted?: boolean | undefined;
};
export declare const CreateToolRequestBodyToolsRequest4McpType: {
    readonly Object: "object";
};
export type CreateToolRequestBodyToolsRequest4McpType = ClosedEnum<typeof CreateToolRequestBodyToolsRequest4McpType>;
/**
 * The original MCP tool input schema for LLM conversion
 */
export type InputSchema = {
    type: CreateToolRequestBodyToolsRequest4McpType;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/**
 * The connection type used by the MCP server
 */
export declare const ConnectionType: {
    readonly Http: "http";
    readonly Sse: "sse";
};
/**
 * The connection type used by the MCP server
 */
export type ConnectionType = ClosedEnum<typeof ConnectionType>;
export type Mcp = {
    /**
     * The ID of the MCP server this tool belongs to
     */
    serverId: string;
    /**
     * The original tool name from the MCP server
     */
    toolName: string;
    /**
     * The MCP server URL (cached for execution)
     */
    serverUrl: string;
    /**
     * HTTP headers for MCP server requests (encrypted format)
     */
    headers?: {
        [k: string]: Headers;
    } | undefined;
    /**
     * The original MCP tool input schema for LLM conversion
     */
    inputSchema: InputSchema;
    /**
     * The connection type used by the MCP server
     */
    connectionType: ConnectionType;
};
/**
 * A tool from a Model Context Protocol (MCP) server that provides standardized access to external capabilities.
 */
export type MCPTool = {
    /**
     * 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: CreateToolRequestBodyToolsRequest4Type;
    mcp: Mcp;
};
/**
 * 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 declare const CreateToolRequestBodyToolsRequestType: {
    readonly Http: "http";
};
export type CreateToolRequestBodyToolsRequestType = ClosedEnum<typeof CreateToolRequestBodyToolsRequestType>;
/**
 * 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>;
/**
 * 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.
     */
    headers?: {
        [k: string]: 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?: CreateToolRequestBodyToolsStatus | undefined;
    type: CreateToolRequestBodyToolsRequestType;
    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 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>;
export declare const CreateToolRequestBodyToolsType: {
    readonly JsonSchema: "json_schema";
};
export type CreateToolRequestBodyToolsType = ClosedEnum<typeof CreateToolRequestBodyToolsType>;
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 | undefined;
    /**
     * 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: {
        [k: string]: any;
    };
    /**
     * 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 JSONSchemaTool = {
    /**
     * 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: CreateToolRequestBodyToolsType;
    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 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>;
export declare const CreateToolRequestBodyType: {
    readonly Function: "function";
};
export type CreateToolRequestBodyType = ClosedEnum<typeof CreateToolRequestBodyType>;
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?: {
        [k: string]: any;
    } | 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?: RequestBodyStatus | undefined;
    type: CreateToolRequestBodyType;
    function: RequestBodyFunction;
};
/**
 * The tool to create
 */
export type CreateToolRequestBody = RequestBodyFunctionTool | JSONSchemaTool | RequestBodyHTTPTool | MCPTool | 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>;
export declare const CreateToolResponseBodyToolsResponse200ApplicationJSONType: {
    readonly Code: "code";
};
export type CreateToolResponseBodyToolsResponse200ApplicationJSONType = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJSONType>;
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?: {
        [k: string]: any;
    } | undefined;
    language: ResponseBodyLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
export type ResponseBody5 = {
    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?: CreateToolResponseBodyToolsResponse200Status | undefined;
    versionHash?: string | undefined;
    type: CreateToolResponseBodyToolsResponse200ApplicationJSONType;
    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 declare const CreateToolResponseBodyToolsResponse200Type: {
    readonly Mcp: "mcp";
};
export type CreateToolResponseBodyToolsResponse200Type = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200Type>;
export type ResponseBodyHeaders = {
    value: string;
    encrypted?: boolean | undefined;
};
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson4Type: {
    readonly Object: "object";
};
export type CreateToolResponseBodyToolsResponse200ApplicationJson4Type = ClosedEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/**
 * The original MCP tool input schema for LLM conversion
 */
export type ResponseBodyInputSchema = {
    type: CreateToolResponseBodyToolsResponse200ApplicationJson4Type;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/**
 * 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 ID of the MCP server this tool belongs to
     */
    serverId: string;
    /**
     * The original tool name from the MCP server
     */
    toolName: string;
    /**
     * The MCP server URL (cached for execution)
     */
    serverUrl: string;
    /**
     * HTTP headers for MCP server requests (encrypted format)
     */
    headers?: {
        [k: string]: ResponseBodyHeaders;
    } | undefined;
    /**
     * The original MCP tool input schema for LLM conversion
     */
    inputSchema: ResponseBodyInputSchema;
    /**
     * The connection type used by the MCP server
     */
    connectionType: ResponseBodyConnectionType;
};
export type ResponseBody4 = {
    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?: CreateToolResponseBodyToolsResponseStatus | undefined;
    versionHash?: string | undefined;
    type: CreateToolResponseBodyToolsResponse200Type;
    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>;
export declare const CreateToolResponseBodyToolsResponseType: {
    readonly Http: "http";
};
export type CreateToolResponseBodyToolsResponseType = ClosedEnum<typeof CreateToolResponseBodyToolsResponseType>;
/**
 * 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>;
/**
 * 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.
     */
    headers?: {
        [k: string]: 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 | undefined;
    /**
     * 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;
};
export type ResponseBody3 = {
    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?: CreateToolResponseBodyToolsStatus | undefined;
    versionHash?: string | undefined;
    type: CreateToolResponseBodyToolsResponseType;
    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>;
export declare const CreateToolResponseBodyToolsType: {
    readonly JsonSchema: "json_schema";
};
export type CreateToolResponseBodyToolsType = ClosedEnum<typeof CreateToolResponseBodyToolsType>;
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 | undefined;
    /**
     * 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: {
        [k: string]: any;
    };
    /**
     * Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the `schema` field. Only a subset of JSON Schema is supported when `strict` is `true`. Only compatible with `OpenAI` models.
     */
    strict?: boolean | undefined;
};
export type ResponseBody2 = {
    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?: CreateToolResponseBodyStatus | undefined;
    versionHash?: string | undefined;
    type: CreateToolResponseBodyToolsType;
    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>;
export declare const CreateToolResponseBodyType: {
    readonly Function: "function";
};
export type CreateToolResponseBodyType = ClosedEnum<typeof CreateToolResponseBodyType>;
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?: {
        [k: string]: any;
    } | undefined;
};
export type ResponseBody1 = {
    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?: ResponseBodyStatus | undefined;
    versionHash?: string | undefined;
    type: CreateToolResponseBodyType;
    function: CreateToolResponseBodyFunction;
};
/**
 * Successfully created the tool.
 */
export type CreateToolResponseBody = ResponseBody1 | ResponseBody2 | ResponseBody3 | ResponseBody4 | ResponseBody5;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest5Status$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest5Status>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest5Status$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest5Status>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest5Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest5Type>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest5Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest5Type>;
/** @internal */
export declare const RequestBodyLanguage$inboundSchema: z.ZodNativeEnum<typeof RequestBodyLanguage>;
/** @internal */
export declare const RequestBodyLanguage$outboundSchema: z.ZodNativeEnum<typeof RequestBodyLanguage>;
/** @internal */
export declare const RequestBodyCodeTool$inboundSchema: z.ZodType<RequestBodyCodeTool, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyCodeTool$Outbound = {
    parameters?: {
        [k: string]: any;
    } | 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;
export declare function requestBodyCodeToolFromJSON(jsonString: string): SafeParseResult<RequestBodyCodeTool, SDKValidationError>;
/** @internal */
export declare const RequestBodyCodeExecutionTool$inboundSchema: z.ZodType<RequestBodyCodeExecutionTool, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyCodeExecutionTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: string;
    code_tool: RequestBodyCodeTool$Outbound;
};
/** @internal */
export declare const RequestBodyCodeExecutionTool$outboundSchema: z.ZodType<RequestBodyCodeExecutionTool$Outbound, z.ZodTypeDef, RequestBodyCodeExecutionTool>;
export declare function requestBodyCodeExecutionToolToJSON(requestBodyCodeExecutionTool: RequestBodyCodeExecutionTool): string;
export declare function requestBodyCodeExecutionToolFromJSON(jsonString: string): SafeParseResult<RequestBodyCodeExecutionTool, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequestStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequestStatus>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequestStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequestStatus>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest4Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest4Type>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest4Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest4Type>;
/** @internal */
export declare const Headers$inboundSchema: z.ZodType<Headers, z.ZodTypeDef, unknown>;
/** @internal */
export type Headers$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const Headers$outboundSchema: z.ZodType<Headers$Outbound, z.ZodTypeDef, Headers>;
export declare function headersToJSON(headers: Headers): string;
export declare function headersFromJSON(jsonString: string): SafeParseResult<Headers, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest4McpType$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest4McpType>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest4McpType$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest4McpType>;
/** @internal */
export declare const InputSchema$inboundSchema: z.ZodType<InputSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type InputSchema$Outbound = {
    type: string;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/** @internal */
export declare const InputSchema$outboundSchema: z.ZodType<InputSchema$Outbound, z.ZodTypeDef, InputSchema>;
export declare function inputSchemaToJSON(inputSchema: InputSchema): string;
export declare function inputSchemaFromJSON(jsonString: string): SafeParseResult<InputSchema, SDKValidationError>;
/** @internal */
export declare const ConnectionType$inboundSchema: z.ZodNativeEnum<typeof ConnectionType>;
/** @internal */
export declare const ConnectionType$outboundSchema: z.ZodNativeEnum<typeof ConnectionType>;
/** @internal */
export declare const Mcp$inboundSchema: z.ZodType<Mcp, z.ZodTypeDef, unknown>;
/** @internal */
export type Mcp$Outbound = {
    server_id: string;
    tool_name: string;
    server_url: string;
    headers?: {
        [k: string]: Headers$Outbound;
    } | undefined;
    input_schema: InputSchema$Outbound;
    connection_type: string;
};
/** @internal */
export declare const Mcp$outboundSchema: z.ZodType<Mcp$Outbound, z.ZodTypeDef, Mcp>;
export declare function mcpToJSON(mcp: Mcp): string;
export declare function mcpFromJSON(jsonString: string): SafeParseResult<Mcp, SDKValidationError>;
/** @internal */
export declare const MCPTool$inboundSchema: z.ZodType<MCPTool, z.ZodTypeDef, unknown>;
/** @internal */
export type MCPTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: string;
    mcp: Mcp$Outbound;
};
/** @internal */
export declare const MCPTool$outboundSchema: z.ZodType<MCPTool$Outbound, z.ZodTypeDef, MCPTool>;
export declare function mcpToolToJSON(mcpTool: MCPTool): string;
export declare function mcpToolFromJSON(jsonString: string): SafeParseResult<MCPTool, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBodyToolsStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsStatus>;
/** @internal */
export declare const CreateToolRequestBodyToolsStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsStatus>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequestType$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequestType>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequestType$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequestType>;
/** @internal */
export declare const CreateToolRequestBodyMethod$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyMethod>;
/** @internal */
export declare const CreateToolRequestBodyMethod$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyMethod>;
/** @internal */
export declare const RequestBodyBlueprint$inboundSchema: z.ZodType<RequestBodyBlueprint, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyBlueprint$Outbound = {
    url: string;
    method: string;
    headers?: {
        [k: string]: 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;
export declare function requestBodyBlueprintFromJSON(jsonString: string): SafeParseResult<RequestBodyBlueprint, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest3Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest3Type>;
/** @internal */
export declare const CreateToolRequestBodyToolsRequest3Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsRequest3Type>;
/** @internal */
export declare const RequestBodyDefaultValue$inboundSchema: z.ZodType<RequestBodyDefaultValue, z.ZodTypeDef, unknown>;
/** @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;
export declare function requestBodyDefaultValueFromJSON(jsonString: string): SafeParseResult<RequestBodyDefaultValue, SDKValidationError>;
/** @internal */
export declare const RequestBodyArguments$inboundSchema: z.ZodType<RequestBodyArguments, z.ZodTypeDef, unknown>;
/** @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;
export declare function requestBodyArgumentsFromJSON(jsonString: string): SafeParseResult<RequestBodyArguments, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBodyHttp$inboundSchema: z.ZodType<CreateToolRequestBodyHttp, z.ZodTypeDef, unknown>;
/** @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;
export declare function createToolRequestBodyHttpFromJSON(jsonString: string): SafeParseResult<CreateToolRequestBodyHttp, SDKValidationError>;
/** @internal */
export declare const RequestBodyHTTPTool$inboundSchema: z.ZodType<RequestBodyHTTPTool, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyHTTPTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: string;
    http: CreateToolRequestBodyHttp$Outbound;
};
/** @internal */
export declare const RequestBodyHTTPTool$outboundSchema: z.ZodType<RequestBodyHTTPTool$Outbound, z.ZodTypeDef, RequestBodyHTTPTool>;
export declare function requestBodyHTTPToolToJSON(requestBodyHTTPTool: RequestBodyHTTPTool): string;
export declare function requestBodyHTTPToolFromJSON(jsonString: string): SafeParseResult<RequestBodyHTTPTool, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBodyStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyStatus>;
/** @internal */
export declare const CreateToolRequestBodyStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyStatus>;
/** @internal */
export declare const CreateToolRequestBodyToolsType$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsType>;
/** @internal */
export declare const CreateToolRequestBodyToolsType$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyToolsType>;
/** @internal */
export declare const RequestBodyJsonSchema$inboundSchema: z.ZodType<RequestBodyJsonSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyJsonSchema$Outbound = {
    name: string;
    description?: string | undefined;
    schema: {
        [k: string]: any;
    };
    strict?: boolean | undefined;
};
/** @internal */
export declare const RequestBodyJsonSchema$outboundSchema: z.ZodType<RequestBodyJsonSchema$Outbound, z.ZodTypeDef, RequestBodyJsonSchema>;
export declare function requestBodyJsonSchemaToJSON(requestBodyJsonSchema: RequestBodyJsonSchema): string;
export declare function requestBodyJsonSchemaFromJSON(jsonString: string): SafeParseResult<RequestBodyJsonSchema, SDKValidationError>;
/** @internal */
export declare const JSONSchemaTool$inboundSchema: z.ZodType<JSONSchemaTool, z.ZodTypeDef, unknown>;
/** @internal */
export type JSONSchemaTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: string;
    json_schema: RequestBodyJsonSchema$Outbound;
};
/** @internal */
export declare const JSONSchemaTool$outboundSchema: z.ZodType<JSONSchemaTool$Outbound, z.ZodTypeDef, JSONSchemaTool>;
export declare function jsonSchemaToolToJSON(jsonSchemaTool: JSONSchemaTool): string;
export declare function jsonSchemaToolFromJSON(jsonString: string): SafeParseResult<JSONSchemaTool, SDKValidationError>;
/** @internal */
export declare const RequestBodyStatus$inboundSchema: z.ZodNativeEnum<typeof RequestBodyStatus>;
/** @internal */
export declare const RequestBodyStatus$outboundSchema: z.ZodNativeEnum<typeof RequestBodyStatus>;
/** @internal */
export declare const CreateToolRequestBodyType$inboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyType>;
/** @internal */
export declare const CreateToolRequestBodyType$outboundSchema: z.ZodNativeEnum<typeof CreateToolRequestBodyType>;
/** @internal */
export declare const RequestBodyFunction$inboundSchema: z.ZodType<RequestBodyFunction, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyFunction$Outbound = {
    name: string;
    description?: string | undefined;
    strict?: boolean | undefined;
    parameters?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const RequestBodyFunction$outboundSchema: z.ZodType<RequestBodyFunction$Outbound, z.ZodTypeDef, RequestBodyFunction>;
export declare function requestBodyFunctionToJSON(requestBodyFunction: RequestBodyFunction): string;
export declare function requestBodyFunctionFromJSON(jsonString: string): SafeParseResult<RequestBodyFunction, SDKValidationError>;
/** @internal */
export declare const RequestBodyFunctionTool$inboundSchema: z.ZodType<RequestBodyFunctionTool, z.ZodTypeDef, unknown>;
/** @internal */
export type RequestBodyFunctionTool$Outbound = {
    path: string;
    key: string;
    display_name?: string | undefined;
    description: string;
    status: string;
    type: string;
    function: RequestBodyFunction$Outbound;
};
/** @internal */
export declare const RequestBodyFunctionTool$outboundSchema: z.ZodType<RequestBodyFunctionTool$Outbound, z.ZodTypeDef, RequestBodyFunctionTool>;
export declare function requestBodyFunctionToolToJSON(requestBodyFunctionTool: RequestBodyFunctionTool): string;
export declare function requestBodyFunctionToolFromJSON(jsonString: string): SafeParseResult<RequestBodyFunctionTool, SDKValidationError>;
/** @internal */
export declare const CreateToolRequestBody$inboundSchema: z.ZodType<CreateToolRequestBody, z.ZodTypeDef, unknown>;
/** @internal */
export type CreateToolRequestBody$Outbound = RequestBodyFunctionTool$Outbound | JSONSchemaTool$Outbound | RequestBodyHTTPTool$Outbound | MCPTool$Outbound | RequestBodyCodeExecutionTool$Outbound;
/** @internal */
export declare const CreateToolRequestBody$outboundSchema: z.ZodType<CreateToolRequestBody$Outbound, z.ZodTypeDef, CreateToolRequestBody>;
export declare function createToolRequestBodyToJSON(createToolRequestBody: CreateToolRequestBody): string;
export declare function createToolRequestBodyFromJSON(jsonString: string): SafeParseResult<CreateToolRequestBody, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200Status$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200Status>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200Status$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200Status>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJSONType>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJSONType$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJSONType>;
/** @internal */
export declare const ResponseBodyLanguage$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyLanguage>;
/** @internal */
export declare const ResponseBodyLanguage$outboundSchema: z.ZodNativeEnum<typeof ResponseBodyLanguage>;
/** @internal */
export declare const ResponseBodyCodeTool$inboundSchema: z.ZodType<ResponseBodyCodeTool, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyCodeTool$Outbound = {
    parameters?: {
        [k: string]: any;
    } | undefined;
    language: string;
    code: string;
};
/** @internal */
export declare const ResponseBodyCodeTool$outboundSchema: z.ZodType<ResponseBodyCodeTool$Outbound, z.ZodTypeDef, ResponseBodyCodeTool>;
export declare function responseBodyCodeToolToJSON(responseBodyCodeTool: ResponseBodyCodeTool): string;
export declare function responseBodyCodeToolFromJSON(jsonString: string): SafeParseResult<ResponseBodyCodeTool, SDKValidationError>;
/** @internal */
export declare const ResponseBody5$inboundSchema: z.ZodType<ResponseBody5, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBody5$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: ResponseBodyCodeTool$Outbound;
};
/** @internal */
export declare const ResponseBody5$outboundSchema: z.ZodType<ResponseBody5$Outbound, z.ZodTypeDef, ResponseBody5>;
export declare function responseBody5ToJSON(responseBody5: ResponseBody5): string;
export declare function responseBody5FromJSON(jsonString: string): SafeParseResult<ResponseBody5, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponseStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponseStatus>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponseStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponseStatus>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200Type>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200Type>;
/** @internal */
export declare const ResponseBodyHeaders$inboundSchema: z.ZodType<ResponseBodyHeaders, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyHeaders$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const ResponseBodyHeaders$outboundSchema: z.ZodType<ResponseBodyHeaders$Outbound, z.ZodTypeDef, ResponseBodyHeaders>;
export declare function responseBodyHeadersToJSON(responseBodyHeaders: ResponseBodyHeaders): string;
export declare function responseBodyHeadersFromJSON(jsonString: string): SafeParseResult<ResponseBodyHeaders, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson4Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson4Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson4Type>;
/** @internal */
export declare const ResponseBodyInputSchema$inboundSchema: z.ZodType<ResponseBodyInputSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyInputSchema$Outbound = {
    type: string;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/** @internal */
export declare const ResponseBodyInputSchema$outboundSchema: z.ZodType<ResponseBodyInputSchema$Outbound, z.ZodTypeDef, ResponseBodyInputSchema>;
export declare function responseBodyInputSchemaToJSON(responseBodyInputSchema: ResponseBodyInputSchema): string;
export declare function responseBodyInputSchemaFromJSON(jsonString: string): SafeParseResult<ResponseBodyInputSchema, SDKValidationError>;
/** @internal */
export declare const ResponseBodyConnectionType$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyConnectionType>;
/** @internal */
export declare const ResponseBodyConnectionType$outboundSchema: z.ZodNativeEnum<typeof ResponseBodyConnectionType>;
/** @internal */
export declare const ResponseBodyMcp$inboundSchema: z.ZodType<ResponseBodyMcp, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyMcp$Outbound = {
    server_id: string;
    tool_name: string;
    server_url: string;
    headers?: {
        [k: string]: ResponseBodyHeaders$Outbound;
    } | undefined;
    input_schema: ResponseBodyInputSchema$Outbound;
    connection_type: string;
};
/** @internal */
export declare const ResponseBodyMcp$outboundSchema: z.ZodType<ResponseBodyMcp$Outbound, z.ZodTypeDef, ResponseBodyMcp>;
export declare function responseBodyMcpToJSON(responseBodyMcp: ResponseBodyMcp): string;
export declare function responseBodyMcpFromJSON(jsonString: string): SafeParseResult<ResponseBodyMcp, SDKValidationError>;
/** @internal */
export declare const ResponseBody4$inboundSchema: z.ZodType<ResponseBody4, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBody4$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: ResponseBodyMcp$Outbound;
};
/** @internal */
export declare const ResponseBody4$outboundSchema: z.ZodType<ResponseBody4$Outbound, z.ZodTypeDef, ResponseBody4>;
export declare function responseBody4ToJSON(responseBody4: ResponseBody4): string;
export declare function responseBody4FromJSON(jsonString: string): SafeParseResult<ResponseBody4, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsStatus>;
/** @internal */
export declare const CreateToolResponseBodyToolsStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsStatus>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponseType$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponseType>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponseType$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponseType>;
/** @internal */
export declare const CreateToolResponseBodyMethod$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyMethod>;
/** @internal */
export declare const CreateToolResponseBodyMethod$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyMethod>;
/** @internal */
export declare const ResponseBodyBlueprint$inboundSchema: z.ZodType<ResponseBodyBlueprint, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyBlueprint$Outbound = {
    url: string;
    method: string;
    headers?: {
        [k: string]: string;
    } | undefined;
    body?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const ResponseBodyBlueprint$outboundSchema: z.ZodType<ResponseBodyBlueprint$Outbound, z.ZodTypeDef, ResponseBodyBlueprint>;
export declare function responseBodyBlueprintToJSON(responseBodyBlueprint: ResponseBodyBlueprint): string;
export declare function responseBodyBlueprintFromJSON(jsonString: string): SafeParseResult<ResponseBodyBlueprint, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson3Type$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/** @internal */
export declare const CreateToolResponseBodyToolsResponse200ApplicationJson3Type$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsResponse200ApplicationJson3Type>;
/** @internal */
export declare const ResponseBodyDefaultValue$inboundSchema: z.ZodType<ResponseBodyDefaultValue, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyDefaultValue$Outbound = string | number | boolean;
/** @internal */
export declare const ResponseBodyDefaultValue$outboundSchema: z.ZodType<ResponseBodyDefaultValue$Outbound, z.ZodTypeDef, ResponseBodyDefaultValue>;
export declare function responseBodyDefaultValueToJSON(responseBodyDefaultValue: ResponseBodyDefaultValue): string;
export declare function responseBodyDefaultValueFromJSON(jsonString: string): SafeParseResult<ResponseBodyDefaultValue, SDKValidationError>;
/** @internal */
export declare const ResponseBodyArguments$inboundSchema: z.ZodType<ResponseBodyArguments, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyArguments$Outbound = {
    type: string;
    description: string;
    send_to_model: boolean;
    default_value?: string | number | boolean | undefined;
};
/** @internal */
export declare const ResponseBodyArguments$outboundSchema: z.ZodType<ResponseBodyArguments$Outbound, z.ZodTypeDef, ResponseBodyArguments>;
export declare function responseBodyArgumentsToJSON(responseBodyArguments: ResponseBodyArguments): string;
export declare function responseBodyArgumentsFromJSON(jsonString: string): SafeParseResult<ResponseBodyArguments, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyHttp$inboundSchema: z.ZodType<CreateToolResponseBodyHttp, z.ZodTypeDef, unknown>;
/** @internal */
export type CreateToolResponseBodyHttp$Outbound = {
    blueprint: ResponseBodyBlueprint$Outbound;
    arguments?: {
        [k: string]: ResponseBodyArguments$Outbound;
    } | undefined;
};
/** @internal */
export declare const CreateToolResponseBodyHttp$outboundSchema: z.ZodType<CreateToolResponseBodyHttp$Outbound, z.ZodTypeDef, CreateToolResponseBodyHttp>;
export declare function createToolResponseBodyHttpToJSON(createToolResponseBodyHttp: CreateToolResponseBodyHttp): string;
export declare function createToolResponseBodyHttpFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodyHttp, SDKValidationError>;
/** @internal */
export declare const ResponseBody3$inboundSchema: z.ZodType<ResponseBody3, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBody3$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: CreateToolResponseBodyHttp$Outbound;
};
/** @internal */
export declare const ResponseBody3$outboundSchema: z.ZodType<ResponseBody3$Outbound, z.ZodTypeDef, ResponseBody3>;
export declare function responseBody3ToJSON(responseBody3: ResponseBody3): string;
export declare function responseBody3FromJSON(jsonString: string): SafeParseResult<ResponseBody3, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyStatus>;
/** @internal */
export declare const CreateToolResponseBodyStatus$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyStatus>;
/** @internal */
export declare const CreateToolResponseBodyToolsType$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsType>;
/** @internal */
export declare const CreateToolResponseBodyToolsType$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyToolsType>;
/** @internal */
export declare const ResponseBodyJsonSchema$inboundSchema: z.ZodType<ResponseBodyJsonSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBodyJsonSchema$Outbound = {
    name: string;
    description?: string | undefined;
    schema: {
        [k: string]: any;
    };
    strict?: boolean | undefined;
};
/** @internal */
export declare const ResponseBodyJsonSchema$outboundSchema: z.ZodType<ResponseBodyJsonSchema$Outbound, z.ZodTypeDef, ResponseBodyJsonSchema>;
export declare function responseBodyJsonSchemaToJSON(responseBodyJsonSchema: ResponseBodyJsonSchema): string;
export declare function responseBodyJsonSchemaFromJSON(jsonString: string): SafeParseResult<ResponseBodyJsonSchema, SDKValidationError>;
/** @internal */
export declare const ResponseBody2$inboundSchema: z.ZodType<ResponseBody2, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBody2$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: ResponseBodyJsonSchema$Outbound;
};
/** @internal */
export declare const ResponseBody2$outboundSchema: z.ZodType<ResponseBody2$Outbound, z.ZodTypeDef, ResponseBody2>;
export declare function responseBody2ToJSON(responseBody2: ResponseBody2): string;
export declare function responseBody2FromJSON(jsonString: string): SafeParseResult<ResponseBody2, SDKValidationError>;
/** @internal */
export declare const ResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyStatus>;
/** @internal */
export declare const ResponseBodyStatus$outboundSchema: z.ZodNativeEnum<typeof ResponseBodyStatus>;
/** @internal */
export declare const CreateToolResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyType>;
/** @internal */
export declare const CreateToolResponseBodyType$outboundSchema: z.ZodNativeEnum<typeof CreateToolResponseBodyType>;
/** @internal */
export declare const CreateToolResponseBodyFunction$inboundSchema: z.ZodType<CreateToolResponseBodyFunction, z.ZodTypeDef, unknown>;
/** @internal */
export type CreateToolResponseBodyFunction$Outbound = {
    name: string;
    description?: string | undefined;
    strict?: boolean | undefined;
    parameters?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const CreateToolResponseBodyFunction$outboundSchema: z.ZodType<CreateToolResponseBodyFunction$Outbound, z.ZodTypeDef, CreateToolResponseBodyFunction>;
export declare function createToolResponseBodyFunctionToJSON(createToolResponseBodyFunction: CreateToolResponseBodyFunction): string;
export declare function createToolResponseBodyFunctionFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBodyFunction, SDKValidationError>;
/** @internal */
export declare const ResponseBody1$inboundSchema: z.ZodType<ResponseBody1, z.ZodTypeDef, unknown>;
/** @internal */
export type ResponseBody1$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: CreateToolResponseBodyFunction$Outbound;
};
/** @internal */
export declare const ResponseBody1$outboundSchema: z.ZodType<ResponseBody1$Outbound, z.ZodTypeDef, ResponseBody1>;
export declare function responseBody1ToJSON(responseBody1: ResponseBody1): string;
export declare function responseBody1FromJSON(jsonString: string): SafeParseResult<ResponseBody1, SDKValidationError>;
/** @internal */
export declare const CreateToolResponseBody$inboundSchema: z.ZodType<CreateToolResponseBody, z.ZodTypeDef, unknown>;
/** @internal */
export type CreateToolResponseBody$Outbound = ResponseBody1$Outbound | ResponseBody2$Outbound | ResponseBody3$Outbound | ResponseBody4$Outbound | ResponseBody5$Outbound;
/** @internal */
export declare const CreateToolResponseBody$outboundSchema: z.ZodType<CreateToolResponseBody$Outbound, z.ZodTypeDef, CreateToolResponseBody>;
export declare function createToolResponseBodyToJSON(createToolResponseBody: CreateToolResponseBody): string;
export declare function createToolResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateToolResponseBody, SDKValidationError>;
//# sourceMappingURL=createtool.d.ts.map