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>;
/**
 * The type must be "object"
 */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody5Type: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type GetAllToolsDataToolsResponse200ApplicationJSONResponseBody5Type = ClosedEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody5Type>;
/**
 * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type GetAllToolsDataParameters = {
    /**
     * The type must be "object"
     */
    type: GetAllToolsDataToolsResponse200ApplicationJSONResponseBody5Type;
    /**
     * The properties of the function parameters
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required parameter names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export declare const 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?: GetAllToolsDataParameters | undefined;
    language: DataLanguage;
    /**
     * The code to execute.
     */
    code: string;
};
/**
 * Executes code snippets in a sandboxed environment, currently supporting Python.
 */
export type DataCodeExecutionTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: GetAllToolsDataToolsResponse200Status;
    type: "code";
    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 type DataHeaders = {
    value: string;
    encrypted: boolean;
};
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody4Type: {
    readonly Object: "object";
};
export type GetAllToolsDataToolsResponse200ApplicationJSONResponseBody4Type = ClosedEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody4Type>;
export type GetAllToolsDataSchema = {
    type: GetAllToolsDataToolsResponse200ApplicationJSONResponseBody4Type;
    properties?: {
        [k: string]: any;
    } | undefined;
    required?: Array<string> | undefined;
};
export type DataTools = {
    id: string;
    name: string;
    description?: string | undefined;
    schema: GetAllToolsDataSchema;
};
/**
 * 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 MCP server URL (cached for execution)
     */
    serverUrl: string;
    /**
     * HTTP headers for MCP server requests with encryption support
     */
    headers?: {
        [k: string]: DataHeaders;
    } | undefined;
    /**
     * Array of tools available from the MCP server
     */
    tools: Array<DataTools>;
    /**
     * The connection type used by the MCP server
     */
    connectionType: DataConnectionType;
    /**
     * Names of template variables detected in server_url and headers. Used by the FE to prompt for one-time values on sync/refresh.
     */
    templateVariables?: Array<string> | null | undefined;
};
/**
 * A tool from a Model Context Protocol (MCP) server that provides standardized access to external capabilities.
 */
export type DataMCPTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: GetAllToolsDataToolsResponseStatus;
    type: "mcp";
    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>;
/**
 * 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>;
export type GetAllToolsHeaders2 = {
    value: string;
    encrypted: boolean;
};
export type GetAllToolsDataHeaders = GetAllToolsHeaders2 | string;
/**
 * The blueprint for the HTTP request. The `arguments` field will be used to replace the placeholders in the `url`, `headers`, `body`, and `arguments` fields.
 */
export type DataBlueprint = {
    /**
     * The URL to send the request to.
     */
    url: string;
    /**
     * The HTTP method to use.
     */
    method: GetAllToolsDataMethod;
    /**
     * The headers to send with the request. Can be a string value or an object with value and encrypted properties.
     */
    headers?: {
        [k: string]: GetAllToolsHeaders2 | 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;
    /**
     * 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;
};
/**
 * Executes HTTP requests to interact with external APIs and web services using customizable blueprints.
 */
export type DataHTTPTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: GetAllToolsDataToolsStatus;
    type: "http";
    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>;
/**
 * The schema for the response format, described as a JSON Schema object. See the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type DataSchema = {
    /**
     * The JSON Schema type
     */
    type: string;
    /**
     * The properties of the JSON Schema object
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required property names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export type 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;
    /**
     * 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: DataSchema;
    /**
     * 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 DataJSONSchemaTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: GetAllToolsDataStatus;
    type: "json_schema";
    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>;
/**
 * The type must be "object"
 */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType: {
    readonly Object: "object";
};
/**
 * The type must be "object"
 */
export type GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType>;
/**
 * The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
 */
export type DataParameters = {
    /**
     * The type must be "object"
     */
    type: GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType;
    /**
     * The properties of the function parameters
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Array of required parameter names
     */
    required: Array<string>;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
export type 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?: DataParameters | undefined;
};
/**
 * A custom function tool that allows the model to call predefined functions with structured parameters.
 */
export type DataFunctionTool = {
    id: string;
    /**
     * Entity storage path in the format: `project/folder/subfolder/...`
     *
     * @remarks
     *
     * The first element identifies the project, followed by nested folders (auto-created as needed).
     *
     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
     */
    path: string;
    /**
     * Unique key of the tool as it will be displayed in the UI
     */
    key: string;
    /**
     * The name of the tool as it will be displayed in the UI. This is optional and if not provided, the `key` will be used.
     */
    displayName?: string | undefined;
    /**
     * A description of the tool, used by the model to choose when and how to call the tool. We do recommend using the `description` field as accurate as possible to give enough context to the model to make the right decision.
     */
    description: string;
    /**
     * The id of the user that created the tool
     */
    createdById?: string | undefined;
    /**
     * The id of the user that last updated the tool
     */
    updatedById?: string | undefined;
    projectId: string;
    workspaceId: string;
    created: string;
    updated: string;
    /**
     * The status of the tool. `Live` is the latest version of the tool. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
     */
    status: DataStatus;
    type: "function";
    function: GetAllToolsDataFunction;
};
export type GetAllToolsData = DataFunctionTool | DataJSONSchemaTool | DataHTTPTool | DataMCPTool | DataCodeExecutionTool;
/**
 * Successfully retrieved the list of tools.
 */
export type GetAllToolsResponseBody = {
    object: GetAllToolsObject;
    data: Array<DataFunctionTool | DataJSONSchemaTool | DataHTTPTool | DataMCPTool | DataCodeExecutionTool>;
    hasMore: boolean;
};
/** @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;
/** @internal */
export declare const GetAllToolsObject$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsObject>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200Status$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200Status>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody5Type$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody5Type>;
/** @internal */
export declare const GetAllToolsDataParameters$inboundSchema: z.ZodType<GetAllToolsDataParameters, z.ZodTypeDef, unknown>;
export declare function getAllToolsDataParametersFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataParameters, SDKValidationError>;
/** @internal */
export declare const DataLanguage$inboundSchema: z.ZodNativeEnum<typeof DataLanguage>;
/** @internal */
export declare const DataCodeTool$inboundSchema: z.ZodType<DataCodeTool, z.ZodTypeDef, unknown>;
export declare function dataCodeToolFromJSON(jsonString: string): SafeParseResult<DataCodeTool, SDKValidationError>;
/** @internal */
export declare const DataCodeExecutionTool$inboundSchema: z.ZodType<DataCodeExecutionTool, z.ZodTypeDef, unknown>;
export declare function dataCodeExecutionToolFromJSON(jsonString: string): SafeParseResult<DataCodeExecutionTool, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsResponseStatus$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponseStatus>;
/** @internal */
export declare const DataHeaders$inboundSchema: z.ZodType<DataHeaders, z.ZodTypeDef, unknown>;
export declare function dataHeadersFromJSON(jsonString: string): SafeParseResult<DataHeaders, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody4Type$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody4Type>;
/** @internal */
export declare const GetAllToolsDataSchema$inboundSchema: z.ZodType<GetAllToolsDataSchema, z.ZodTypeDef, unknown>;
export declare function getAllToolsDataSchemaFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataSchema, SDKValidationError>;
/** @internal */
export declare const DataTools$inboundSchema: z.ZodType<DataTools, z.ZodTypeDef, unknown>;
export declare function dataToolsFromJSON(jsonString: string): SafeParseResult<DataTools, SDKValidationError>;
/** @internal */
export declare const DataConnectionType$inboundSchema: z.ZodNativeEnum<typeof DataConnectionType>;
/** @internal */
export declare const DataMcp$inboundSchema: z.ZodType<DataMcp, z.ZodTypeDef, unknown>;
export declare function dataMcpFromJSON(jsonString: string): SafeParseResult<DataMcp, SDKValidationError>;
/** @internal */
export declare const DataMCPTool$inboundSchema: z.ZodType<DataMCPTool, z.ZodTypeDef, unknown>;
export declare function dataMCPToolFromJSON(jsonString: string): SafeParseResult<DataMCPTool, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsStatus$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsStatus>;
/** @internal */
export declare const GetAllToolsDataMethod$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataMethod>;
/** @internal */
export declare const GetAllToolsHeaders2$inboundSchema: z.ZodType<GetAllToolsHeaders2, z.ZodTypeDef, unknown>;
export declare function getAllToolsHeaders2FromJSON(jsonString: string): SafeParseResult<GetAllToolsHeaders2, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataHeaders$inboundSchema: z.ZodType<GetAllToolsDataHeaders, z.ZodTypeDef, unknown>;
export declare function getAllToolsDataHeadersFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataHeaders, SDKValidationError>;
/** @internal */
export declare const DataBlueprint$inboundSchema: z.ZodType<DataBlueprint, z.ZodTypeDef, unknown>;
export declare function dataBlueprintFromJSON(jsonString: string): SafeParseResult<DataBlueprint, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBody3Type>;
/** @internal */
export declare const DataDefaultValue$inboundSchema: z.ZodType<DataDefaultValue, z.ZodTypeDef, unknown>;
export declare function dataDefaultValueFromJSON(jsonString: string): SafeParseResult<DataDefaultValue, SDKValidationError>;
/** @internal */
export declare const DataArguments$inboundSchema: z.ZodType<DataArguments, z.ZodTypeDef, unknown>;
export declare function dataArgumentsFromJSON(jsonString: string): SafeParseResult<DataArguments, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataHttp$inboundSchema: z.ZodType<GetAllToolsDataHttp, z.ZodTypeDef, unknown>;
export declare function getAllToolsDataHttpFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataHttp, SDKValidationError>;
/** @internal */
export declare const DataHTTPTool$inboundSchema: z.ZodType<DataHTTPTool, z.ZodTypeDef, unknown>;
export declare function dataHTTPToolFromJSON(jsonString: string): SafeParseResult<DataHTTPTool, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataStatus$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataStatus>;
/** @internal */
export declare const DataSchema$inboundSchema: z.ZodType<DataSchema, z.ZodTypeDef, unknown>;
export declare function dataSchemaFromJSON(jsonString: string): SafeParseResult<DataSchema, SDKValidationError>;
/** @internal */
export declare const DataJsonSchema$inboundSchema: z.ZodType<DataJsonSchema, z.ZodTypeDef, unknown>;
export declare function dataJsonSchemaFromJSON(jsonString: string): SafeParseResult<DataJsonSchema, SDKValidationError>;
/** @internal */
export declare const DataJSONSchemaTool$inboundSchema: z.ZodType<DataJSONSchemaTool, z.ZodTypeDef, unknown>;
export declare function dataJSONSchemaToolFromJSON(jsonString: string): SafeParseResult<DataJSONSchemaTool, SDKValidationError>;
/** @internal */
export declare const DataStatus$inboundSchema: z.ZodNativeEnum<typeof DataStatus>;
/** @internal */
export declare const GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof GetAllToolsDataToolsResponse200ApplicationJSONResponseBodyType>;
/** @internal */
export declare const DataParameters$inboundSchema: z.ZodType<DataParameters, z.ZodTypeDef, unknown>;
export declare function dataParametersFromJSON(jsonString: string): SafeParseResult<DataParameters, SDKValidationError>;
/** @internal */
export declare const GetAllToolsDataFunction$inboundSchema: z.ZodType<GetAllToolsDataFunction, z.ZodTypeDef, unknown>;
export declare function getAllToolsDataFunctionFromJSON(jsonString: string): SafeParseResult<GetAllToolsDataFunction, SDKValidationError>;
/** @internal */
export declare const DataFunctionTool$inboundSchema: z.ZodType<DataFunctionTool, z.ZodTypeDef, unknown>;
export declare function dataFunctionToolFromJSON(jsonString: string): SafeParseResult<DataFunctionTool, SDKValidationError>;
/** @internal */
export declare const GetAllToolsData$inboundSchema: z.ZodType<GetAllToolsData, z.ZodTypeDef, unknown>;
export declare function getAllToolsDataFromJSON(jsonString: string): SafeParseResult<GetAllToolsData, SDKValidationError>;
/** @internal */
export declare const GetAllToolsResponseBody$inboundSchema: z.ZodType<GetAllToolsResponseBody, z.ZodTypeDef, unknown>;
export declare function getAllToolsResponseBodyFromJSON(jsonString: string): SafeParseResult<GetAllToolsResponseBody, SDKValidationError>;
//# sourceMappingURL=getalltools.d.ts.map