import type { Files } from "../index.js";
import type { ToolOptions } from "./types.js";
export declare const listFiles: (files: Files) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
        output: NoInfer<{
            cursor: string | undefined;
            items: {
                etag: string | undefined;
                key: string;
                lastModified: number | undefined;
                size: number;
                type: string;
            }[];
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
        output: NoInfer<{
            cursor: string | undefined;
            items: {
                etag: string | undefined;
                key: string;
                lastModified: number | undefined;
                size: number;
                type: string;
            }[];
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
        output: NoInfer<{
            cursor: string | undefined;
            items: {
                etag: string | undefined;
                key: string;
                lastModified: number | undefined;
                size: number;
                type: string;
            }[];
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cursor?: string | undefined;
            limit?: number | undefined;
            prefix?: string | undefined;
        };
        output: NoInfer<{
            cursor: string | undefined;
            items: {
                etag: string | undefined;
                key: string;
                lastModified: number | undefined;
                size: number;
                type: string;
            }[];
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        cursor?: string | undefined;
        limit?: number | undefined;
        prefix?: string | undefined;
    }, {
        cursor: string | undefined;
        items: {
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
            type: string;
        }[];
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const getFileMetadata: (files: Files) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            metadata: Record<string, string> | undefined;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            key: string;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            metadata: Record<string, string> | undefined;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            key: string;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            metadata: Record<string, string> | undefined;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            metadata: Record<string, string> | undefined;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        metadata: Record<string, string> | undefined;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const downloadFile: (files: Files) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
        output: NoInfer<{
            content: string;
            encoding: "base64";
            key: string;
            size: number;
            type: string;
        } | {
            content: string;
            encoding: "text";
            key: string;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
        output: NoInfer<{
            content: string;
            encoding: "base64";
            key: string;
            size: number;
            type: string;
        } | {
            content: string;
            encoding: "text";
            key: string;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
        output: NoInfer<{
            content: string;
            encoding: "base64";
            key: string;
            size: number;
            type: string;
        } | {
            content: string;
            encoding: "text";
            key: string;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            binary?: boolean | undefined;
            key: string;
            maxBytes?: number | undefined;
        };
        output: NoInfer<{
            content: string;
            encoding: "base64";
            key: string;
            size: number;
            type: string;
        } | {
            content: string;
            encoding: "text";
            key: string;
            size: number;
            type: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        binary?: boolean | undefined;
        key: string;
        maxBytes?: number | undefined;
    }, {
        content: string;
        encoding: "base64";
        key: string;
        size: number;
        type: string;
    } | {
        content: string;
        encoding: "text";
        key: string;
        size: number;
        type: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const getFileUrl: (files: Files) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
        output: NoInfer<{
            key: string;
            url: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        key: string;
        url: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
        output: NoInfer<{
            key: string;
            url: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        key: string;
        url: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
        output: NoInfer<{
            key: string;
            url: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        key: string;
        url: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            expiresIn?: number | undefined;
            key: string;
            responseContentDisposition?: string | undefined;
        };
        output: NoInfer<{
            key: string;
            url: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        key: string;
        url: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        expiresIn?: number | undefined;
        key: string;
        responseContentDisposition?: string | undefined;
    }, {
        key: string;
        url: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const uploadFile: (files: Files, { needsApproval }?: ToolOptions) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
        output: NoInfer<{
            contentType: string;
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
        output: NoInfer<{
            contentType: string;
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
        output: NoInfer<{
            contentType: string;
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            cacheControl?: string | undefined;
            content: string;
            contentType?: string | undefined;
            encoding?: "base64" | "text" | undefined;
            key: string;
            metadata?: Record<string, string> | undefined;
        };
        output: NoInfer<{
            contentType: string;
            etag: string | undefined;
            key: string;
            lastModified: number | undefined;
            size: number;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        cacheControl?: string | undefined;
        content: string;
        contentType?: string | undefined;
        encoding?: "base64" | "text" | undefined;
        key: string;
        metadata?: Record<string, string> | undefined;
    }, {
        contentType: string;
        etag: string | undefined;
        key: string;
        lastModified: number | undefined;
        size: number;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const deleteFile: (files: Files, { needsApproval }?: ToolOptions) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            deleted: true;
            key: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        deleted: true;
        key: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            key: string;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            deleted: true;
            key: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        deleted: true;
        key: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            key: string;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            deleted: true;
            key: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        deleted: true;
        key: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        key: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            key: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            key: string;
        };
        output: NoInfer<{
            deleted: true;
            key: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        deleted: true;
        key: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        key: string;
    }, {
        deleted: true;
        key: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const copyFile: (files: Files, { needsApproval }?: ToolOptions) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        from: string;
        to: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            from: string;
            to: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            from: string;
            to: string;
        };
        output: NoInfer<{
            copied: true;
            from: string;
            to: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        copied: true;
        from: string;
        to: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            from: string;
            to: string;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        from: string;
        to: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            from: string;
            to: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            from: string;
            to: string;
        };
        output: NoInfer<{
            copied: true;
            from: string;
            to: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        copied: true;
        from: string;
        to: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            from: string;
            to: string;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        from: string;
        to: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            from: string;
            to: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            from: string;
            to: string;
        };
        output: NoInfer<{
            copied: true;
            from: string;
            to: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        copied: true;
        from: string;
        to: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        from: string;
        to: string;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            from: string;
            to: string;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            from: string;
            to: string;
        };
        output: NoInfer<{
            copied: true;
            from: string;
            to: string;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        copied: true;
        from: string;
        to: string;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        from: string;
        to: string;
    }, {
        copied: true;
        from: string;
        to: string;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
export declare const signUploadUrl: (files: Files, { needsApproval }?: ToolOptions) => ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
        output: NoInfer<import("../index.js").SignedUpload>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<import("../index.js").SignedUpload> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | 'function';
} & {
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
        output: NoInfer<import("../index.js").SignedUpload>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<import("../index.js").SignedUpload> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: 'dynamic';
} & {
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
        output: NoInfer<import("../index.js").SignedUpload>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<import("../index.js").SignedUpload> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            contentType?: string | undefined;
            expiresIn: number;
            key: string;
            maxSize?: number | undefined;
            minSize?: number | undefined;
        };
        output: NoInfer<import("../index.js").SignedUpload>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<import("../index.js").SignedUpload> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: 'provider';
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        contentType?: string | undefined;
        expiresIn: number;
        key: string;
        maxSize?: number | undefined;
        minSize?: number | undefined;
    }, import("../index.js").SignedUpload, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
//# sourceMappingURL=tools.d.ts.map