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";
export type GetAllToolsRequest = {
    /**
     * Maximum number of tools per page (1-200). Omit to return all tools.
     */
    limit?: number | undefined;
    /**
     * A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, ending with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `after=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the next page of the list.
     */
    startingAfter?: string | undefined;
    /**
     * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list.
     */
    endingBefore?: string | undefined;
};
export declare const GetAllToolsObject: {
    readonly List: "list";
};
export type GetAllToolsObject = ClosedEnum<typeof GetAllToolsObject>;
/**
 * 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 GetAllToolsDataToolsResponse200Status: {
    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 GetAllToolsDataToolsResponse200Status = ClosedEnum<typeof GetAllToolsDataToolsResponse200Status>;
export declare const GetAllToolsDataToolsResponse200ApplicationJSONType: {
    readonly Code: "code";
};
export type GetAllToolsDataToolsResponse200ApplicationJSONType = ClosedEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONType>;
export declare const DataLanguage: {
    readonly Python: "python";
};
export type DataLanguage = ClosedEnum<typeof DataLanguage>;
export type DataCodeTool = {
    /**
     * 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: DataLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
export type Data5 = {
    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?: GetAllToolsDataToolsResponse200Status | undefined;
    versionHash?: string | undefined;
    type: GetAllToolsDataToolsResponse200ApplicationJSONType;
    codeTool: DataCodeTool;
};
/**
 * 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 GetAllToolsDataToolsResponseStatus: {
    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 GetAllToolsDataToolsResponseStatus = ClosedEnum<typeof GetAllToolsDataToolsResponseStatus>;
export declare const GetAllToolsDataToolsResponse200Type: {
    readonly Mcp: "mcp";
};
export type GetAllToolsDataToolsResponse200Type = ClosedEnum<typeof GetAllToolsDataToolsResponse200Type>;
export type DataHeaders = {
    value: string;
    encrypted?: boolean | undefined;
};
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType: {
    readonly Object: "object";
};
export type GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType>;
/**
 * The original MCP tool input schema for LLM conversion
 */
export type DataInputSchema = {
    type: GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/**
 * The connection type used by the MCP server
 */
export declare const DataConnectionType: {
    readonly Http: "http";
    readonly Sse: "sse";
};
/**
 * The connection type used by the MCP server
 */
export type DataConnectionType = ClosedEnum<typeof DataConnectionType>;
export type DataMcp = {
    /**
     * 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]: DataHeaders;
    } | undefined;
    /**
     * The original MCP tool input schema for LLM conversion
     */
    inputSchema: DataInputSchema;
    /**
     * The connection type used by the MCP server
     */
    connectionType: DataConnectionType;
};
export type Data4 = {
    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?: GetAllToolsDataToolsResponseStatus | undefined;
    versionHash?: string | undefined;
    type: GetAllToolsDataToolsResponse200Type;
    mcp: DataMcp;
};
/**
 * 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 GetAllToolsDataToolsStatus: {
    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 GetAllToolsDataToolsStatus = ClosedEnum<typeof GetAllToolsDataToolsStatus>;
export declare const GetAllToolsDataToolsResponseType: {
    readonly Http: "http";
};
export type GetAllToolsDataToolsResponseType = ClosedEnum<typeof GetAllToolsDataToolsResponseType>;
/**
 * The HTTP method to use.
 */
export declare const GetAllToolsDataMethod: {
    readonly Get: "GET";
    readonly Post: "POST";
    readonly Put: "PUT";
    readonly Delete: "DELETE";
};
/**
 * The HTTP method to use.
 */
export type GetAllToolsDataMethod = ClosedEnum<typeof GetAllToolsDataMethod>;
/**
 * 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 DataBlueprint = {
    /**
     * The URL to send the request to.
     */
    url: string;
    /**
     * The HTTP method to use.
     */
    method: GetAllToolsDataMethod;
    /**
     * 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 GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type: {
    readonly String: "string";
    readonly Number: "number";
    readonly Boolean: "boolean";
};
/**
 * The type of the argument.
 */
export type GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type = ClosedEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type>;
/**
 * The default value of the argument.
 */
export type DataDefaultValue = string | number | boolean;
export type DataArguments = {
    /**
     * The type of the argument.
     */
    type: GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type;
    /**
     * 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 GetAllToolsDataHttp = {
    /**
     * 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: DataBlueprint;
    /**
     * The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field.
     */
    arguments?: {
        [k: string]: DataArguments;
    } | undefined;
};
export type Data3 = {
    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?: GetAllToolsDataToolsStatus | undefined;
    versionHash?: string | undefined;
    type: GetAllToolsDataToolsResponseType;
    http: GetAllToolsDataHttp;
};
/**
 * 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 GetAllToolsDataStatus: {
    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 GetAllToolsDataStatus = ClosedEnum<typeof GetAllToolsDataStatus>;
export declare const GetAllToolsDataToolsType: {
    readonly JsonSchema: "json_schema";
};
export type GetAllToolsDataToolsType = ClosedEnum<typeof GetAllToolsDataToolsType>;
export type DataJsonSchema = {
    /**
     * 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 Data2 = {
    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?: GetAllToolsDataStatus | undefined;
    versionHash?: string | undefined;
    type: GetAllToolsDataToolsType;
    jsonSchema: DataJsonSchema;
};
/**
 * 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 DataStatus: {
    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 DataStatus = ClosedEnum<typeof DataStatus>;
export declare const GetAllToolsDataType: {
    readonly Function: "function";
};
export type GetAllToolsDataType = ClosedEnum<typeof GetAllToolsDataType>;
export type GetAllToolsDataFunction = {
    /**
     * 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 Data1 = {
    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?: DataStatus | undefined;
    versionHash?: string | undefined;
    type: GetAllToolsDataType;
    function: GetAllToolsDataFunction;
};
export type GetAllToolsData = Data1 | Data2 | Data3 | Data4 | Data5;
/**
 * Successfully retrieved the list of tools.
 */
export type GetAllToolsResponseBody = {
    object: GetAllToolsObject;
    data: Array<Data1 | Data2 | Data3 | Data4 | Data5>;
    hasMore: boolean;
};
/** @internal */
export declare const GetAllToolsRequest$inboundSchema: z.ZodType<GetAllToolsRequest, z.ZodTypeDef, unknown>;
/** @internal */
export type GetAllToolsRequest$Outbound = {
    limit?: number | undefined;
    starting_after?: string | undefined;
    ending_before?: string | undefined;
};
/** @internal */
export declare const GetAllToolsRequest$outboundSchema: z.ZodType<GetAllToolsRequest$Outbound, z.ZodTypeDef, GetAllToolsRequest>;
export declare function getAllToolsRequestToJSON(getAllToolsRequest: GetAllToolsRequest): string;
export declare function getAllToolsRequestFromJSON(jsonString: string): SafeParseResult<GetAllToolsRequest, SDKValidationError>;
/** @internal */
export declare const GetAllToolsObject$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsObject>;
/** @internal */
export declare const GetAllToolsObject$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsObject>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200Status$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200Status>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200Status$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200Status>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONType>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONType$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONType>;
/** @internal */
export declare const DataLanguage$inboundSchema: z.ZodNativeEnum<typeof DataLanguage>;
/** @internal */
export declare const DataLanguage$outboundSchema: z.ZodNativeEnum<typeof DataLanguage>;
/** @internal */
export declare const DataCodeTool$inboundSchema: z.ZodType<DataCodeTool, z.ZodTypeDef, unknown>;
/** @internal */
export type DataCodeTool$Outbound = {
    parameters?: {
        [k: string]: any;
    } | undefined;
    language: string;
    code: string;
};
/** @internal */
export declare const DataCodeTool$outboundSchema: z.ZodType<DataCodeTool$Outbound, z.ZodTypeDef, DataCodeTool>;
export declare function dataCodeToolToJSON(dataCodeTool: DataCodeTool): string;
export declare function dataCodeToolFromJSON(jsonString: string): SafeParseResult<DataCodeTool, SDKValidationError>;
/** @internal */
export declare const Data5$inboundSchema: z.ZodType<Data5, z.ZodTypeDef, unknown>;
/** @internal */
export type Data5$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: DataCodeTool$Outbound;
};
/** @internal */
export declare const Data5$outboundSchema: z.ZodType<Data5$Outbound, z.ZodTypeDef, Data5>;
export declare function data5ToJSON(data5: Data5): string;
export declare function data5FromJSON(jsonString: string): SafeParseResult<Data5, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsResponseStatus$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponseStatus>;
/** @internal */
export declare const GetAllToolsDataToolsResponseStatus$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponseStatus>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200Type>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200Type>;
/** @internal */
export declare const DataHeaders$inboundSchema: z.ZodType<DataHeaders, z.ZodTypeDef, unknown>;
/** @internal */
export type DataHeaders$Outbound = {
    value: string;
    encrypted: boolean;
};
/** @internal */
export declare const DataHeaders$outboundSchema: z.ZodType<DataHeaders$Outbound, z.ZodTypeDef, DataHeaders>;
export declare function dataHeadersToJSON(dataHeaders: DataHeaders): string;
export declare function dataHeadersFromJSON(jsonString: string): SafeParseResult<DataHeaders, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType>;
/** @internal */
export declare const DataInputSchema$inboundSchema: z.ZodType<DataInputSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type DataInputSchema$Outbound = {
    type: string;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
/** @internal */
export declare const DataInputSchema$outboundSchema: z.ZodType<DataInputSchema$Outbound, z.ZodTypeDef, DataInputSchema>;
export declare function dataInputSchemaToJSON(dataInputSchema: DataInputSchema): string;
export declare function dataInputSchemaFromJSON(jsonString: string): SafeParseResult<DataInputSchema, SDKValidationError>;
/** @internal */
export declare const DataConnectionType$inboundSchema: z.ZodNativeEnum<typeof DataConnectionType>;
/** @internal */
export declare const DataConnectionType$outboundSchema: z.ZodNativeEnum<typeof DataConnectionType>;
/** @internal */
export declare const DataMcp$inboundSchema: z.ZodType<DataMcp, z.ZodTypeDef, unknown>;
/** @internal */
export type DataMcp$Outbound = {
    server_id: string;
    tool_name: string;
    server_url: string;
    headers?: {
        [k: string]: DataHeaders$Outbound;
    } | undefined;
    input_schema: DataInputSchema$Outbound;
    connection_type: string;
};
/** @internal */
export declare const DataMcp$outboundSchema: z.ZodType<DataMcp$Outbound, z.ZodTypeDef, DataMcp>;
export declare function dataMcpToJSON(dataMcp: DataMcp): string;
export declare function dataMcpFromJSON(jsonString: string): SafeParseResult<DataMcp, SDKValidationError>;
/** @internal */
export declare const Data4$inboundSchema: z.ZodType<Data4, z.ZodTypeDef, unknown>;
/** @internal */
export type Data4$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: DataMcp$Outbound;
};
/** @internal */
export declare const Data4$outboundSchema: z.ZodType<Data4$Outbound, z.ZodTypeDef, Data4>;
export declare function data4ToJSON(data4: Data4): string;
export declare function data4FromJSON(jsonString: string): SafeParseResult<Data4, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsStatus$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsStatus>;
/** @internal */
export declare const GetAllToolsDataToolsStatus$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsStatus>;
/** @internal */
export declare const GetAllToolsDataToolsResponseType$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponseType>;
/** @internal */
export declare const GetAllToolsDataToolsResponseType$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponseType>;
/** @internal */
export declare const GetAllToolsDataMethod$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataMethod>;
/** @internal */
export declare const GetAllToolsDataMethod$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataMethod>;
/** @internal */
export declare const DataBlueprint$inboundSchema: z.ZodType<DataBlueprint, z.ZodTypeDef, unknown>;
/** @internal */
export type DataBlueprint$Outbound = {
    url: string;
    method: string;
    headers?: {
        [k: string]: string;
    } | undefined;
    body?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const DataBlueprint$outboundSchema: z.ZodType<DataBlueprint$Outbound, z.ZodTypeDef, DataBlueprint>;
export declare function dataBlueprintToJSON(dataBlueprint: DataBlueprint): string;
export declare function dataBlueprintFromJSON(jsonString: string): SafeParseResult<DataBlueprint, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type>;
/** @internal */
export declare const DataDefaultValue$inboundSchema: z.ZodType<DataDefaultValue, z.ZodTypeDef, unknown>;
/** @internal */
export type DataDefaultValue$Outbound = string | number | boolean;
/** @internal */
export declare const DataDefaultValue$outboundSchema: z.ZodType<DataDefaultValue$Outbound, z.ZodTypeDef, DataDefaultValue>;
export declare function dataDefaultValueToJSON(dataDefaultValue: DataDefaultValue): string;
export declare function dataDefaultValueFromJSON(jsonString: string): SafeParseResult<DataDefaultValue, SDKValidationError>;
/** @internal */
export declare const DataArguments$inboundSchema: z.ZodType<DataArguments, z.ZodTypeDef, unknown>;
/** @internal */
export type DataArguments$Outbound = {
    type: string;
    description: string;
    send_to_model: boolean;
    default_value?: string | number | boolean | undefined;
};
/** @internal */
export declare const DataArguments$outboundSchema: z.ZodType<DataArguments$Outbound, z.ZodTypeDef, DataArguments>;
export declare function dataArgumentsToJSON(dataArguments: DataArguments): string;
export declare function dataArgumentsFromJSON(jsonString: string): SafeParseResult<DataArguments, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataHttp$inboundSchema: z.ZodType<GetAllToolsDataHttp, z.ZodTypeDef, unknown>;
/** @internal */
export type GetAllToolsDataHttp$Outbound = {
    blueprint: DataBlueprint$Outbound;
    arguments?: {
        [k: string]: DataArguments$Outbound;
    } | undefined;
};
/** @internal */
export declare const GetAllToolsDataHttp$outboundSchema: z.ZodType<GetAllToolsDataHttp$Outbound, z.ZodTypeDef, GetAllToolsDataHttp>;
export declare function getAllToolsDataHttpToJSON(getAllToolsDataHttp: GetAllToolsDataHttp): string;
export declare function getAllToolsDataHttpFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataHttp, SDKValidationError>;
/** @internal */
export declare const Data3$inboundSchema: z.ZodType<Data3, z.ZodTypeDef, unknown>;
/** @internal */
export type Data3$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: GetAllToolsDataHttp$Outbound;
};
/** @internal */
export declare const Data3$outboundSchema: z.ZodType<Data3$Outbound, z.ZodTypeDef, Data3>;
export declare function data3ToJSON(data3: Data3): string;
export declare function data3FromJSON(jsonString: string): SafeParseResult<Data3, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataStatus$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataStatus>;
/** @internal */
export declare const GetAllToolsDataStatus$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataStatus>;
/** @internal */
export declare const GetAllToolsDataToolsType$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsType>;
/** @internal */
export declare const GetAllToolsDataToolsType$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsType>;
/** @internal */
export declare const DataJsonSchema$inboundSchema: z.ZodType<DataJsonSchema, z.ZodTypeDef, unknown>;
/** @internal */
export type DataJsonSchema$Outbound = {
    name: string;
    description?: string | undefined;
    schema: {
        [k: string]: any;
    };
    strict?: boolean | undefined;
};
/** @internal */
export declare const DataJsonSchema$outboundSchema: z.ZodType<DataJsonSchema$Outbound, z.ZodTypeDef, DataJsonSchema>;
export declare function dataJsonSchemaToJSON(dataJsonSchema: DataJsonSchema): string;
export declare function dataJsonSchemaFromJSON(jsonString: string): SafeParseResult<DataJsonSchema, SDKValidationError>;
/** @internal */
export declare const Data2$inboundSchema: z.ZodType<Data2, z.ZodTypeDef, unknown>;
/** @internal */
export type Data2$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: DataJsonSchema$Outbound;
};
/** @internal */
export declare const Data2$outboundSchema: z.ZodType<Data2$Outbound, z.ZodTypeDef, Data2>;
export declare function data2ToJSON(data2: Data2): string;
export declare function data2FromJSON(jsonString: string): SafeParseResult<Data2, SDKValidationError>;
/** @internal */
export declare const DataStatus$inboundSchema: z.ZodNativeEnum<typeof DataStatus>;
/** @internal */
export declare const DataStatus$outboundSchema: z.ZodNativeEnum<typeof DataStatus>;
/** @internal */
export declare const GetAllToolsDataType$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataType>;
/** @internal */
export declare const GetAllToolsDataType$outboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataType>;
/** @internal */
export declare const GetAllToolsDataFunction$inboundSchema: z.ZodType<GetAllToolsDataFunction, z.ZodTypeDef, unknown>;
/** @internal */
export type GetAllToolsDataFunction$Outbound = {
    name: string;
    description?: string | undefined;
    strict?: boolean | undefined;
    parameters?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const GetAllToolsDataFunction$outboundSchema: z.ZodType<GetAllToolsDataFunction$Outbound, z.ZodTypeDef, GetAllToolsDataFunction>;
export declare function getAllToolsDataFunctionToJSON(getAllToolsDataFunction: GetAllToolsDataFunction): string;
export declare function getAllToolsDataFunctionFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataFunction, SDKValidationError>;
/** @internal */
export declare const Data1$inboundSchema: z.ZodType<Data1, z.ZodTypeDef, unknown>;
/** @internal */
export type Data1$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: GetAllToolsDataFunction$Outbound;
};
/** @internal */
export declare const Data1$outboundSchema: z.ZodType<Data1$Outbound, z.ZodTypeDef, Data1>;
export declare function data1ToJSON(data1: Data1): string;
export declare function data1FromJSON(jsonString: string): SafeParseResult<Data1, SDKValidationError>;
/** @internal */
export declare const GetAllToolsData$inboundSchema: z.ZodType<GetAllToolsData, z.ZodTypeDef, unknown>;
/** @internal */
export type GetAllToolsData$Outbound = Data1$Outbound | Data2$Outbound | Data3$Outbound | Data4$Outbound | Data5$Outbound;
/** @internal */
export declare const GetAllToolsData$outboundSchema: z.ZodType<GetAllToolsData$Outbound, z.ZodTypeDef, GetAllToolsData>;
export declare function getAllToolsDataToJSON(getAllToolsData: GetAllToolsData): string;
export declare function getAllToolsDataFromJSON(jsonString: string): SafeParseResult<GetAllToolsData, SDKValidationError>;
/** @internal */
export declare const GetAllToolsResponseBody$inboundSchema: z.ZodType<GetAllToolsResponseBody, z.ZodTypeDef, unknown>;
/** @internal */
export type GetAllToolsResponseBody$Outbound = {
    object: string;
    data: Array<Data1$Outbound | Data2$Outbound | Data3$Outbound | Data4$Outbound | Data5$Outbound>;
    has_more: boolean;
};
/** @internal */
export declare const GetAllToolsResponseBody$outboundSchema: z.ZodType<GetAllToolsResponseBody$Outbound, z.ZodTypeDef, GetAllToolsResponseBody>;
export declare function getAllToolsResponseBodyToJSON(getAllToolsResponseBody: GetAllToolsResponseBody): string;
export declare function getAllToolsResponseBodyFromJSON(jsonString: string): SafeParseResult<GetAllToolsResponseBody, SDKValidationError>;
//# sourceMappingURL=getalltools.d.ts.map