@visulima/storage 1.0.0-alpha.9 → 1.0.0

package/dist/ai/openai/index.d.ts

@@ -0,0 +1,205 @@
+import { T as TOOL_SCHEMAS, F as FileToolName, A as ApprovalConfig, c as FileReadToolName } from "../../packem_shared/approval.d-CMAYH9GF.js";
+export type { d as FileWriteToolName } from "../../packem_shared/approval.d-CMAYH9GF.js";
+import { UnknownContext, FunctionTool } from '@openai/agents';
+import { F as Files } from "../../packem_shared/files.d-CH0iLBNC.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import { e as executors } from "../../packem_shared/executors.d-BZP2rWo3.js";
+import 'zod';
+import "../../packem_shared/storage.d-CEM1upWM.js";
+/**
+* Per-tool overrides for `createResponsesFileTools`. `name`, `parameters`, and
+* `type` are intentionally not overridable — the contract that drives tool
+* behavior should not be patched at this layer.
+*/
+interface ResponsesToolOverrides {
+  description?: string;
+  strict?: boolean;
+}
+/**
+* Per-tool overrides for `createAgentsFileTools`. `name`, `parameters`,
+* `execute`, and `strict` are intentionally not overridable — the contract
+* that drives tool behavior should not be patched at this layer.
+*/
+interface AgentsToolOverrides {
+  description?: string;
+  needsApproval?: boolean;
+}
+type ListFilesOutput = Awaited<ReturnType<typeof executors.listFiles>>;
+type GetFileMetadataOutput = Awaited<ReturnType<typeof executors.getFileMetadata>>;
+type DownloadFileOutput = Awaited<ReturnType<typeof executors.downloadFile>>;
+type GetFileUrlOutput = Awaited<ReturnType<typeof executors.getFileUrl>>;
+type UploadFileOutput = Awaited<ReturnType<typeof executors.uploadFile>>;
+type DeleteFileOutput = Awaited<ReturnType<typeof executors.deleteFile>>;
+type CopyFileOutput = Awaited<ReturnType<typeof executors.copyFile>>;
+type SignUploadUrlOutput = Awaited<ReturnType<typeof executors.signUploadUrl>>;
+type ListFilesParameters = typeof TOOL_SCHEMAS.listFiles.input;
+type GetFileMetadataParameters = typeof TOOL_SCHEMAS.getFileMetadata.input;
+type DownloadFileParameters = typeof TOOL_SCHEMAS.downloadFile.input;
+type GetFileUrlParameters = typeof TOOL_SCHEMAS.getFileUrl.input;
+type UploadFileParameters = typeof TOOL_SCHEMAS.uploadFile.input;
+type DeleteFileParameters = typeof TOOL_SCHEMAS.deleteFile.input;
+type CopyFileParameters = typeof TOOL_SCHEMAS.copyFile.input;
+type SignUploadUrlParameters = typeof TOOL_SCHEMAS.signUploadUrl.input;
+declare const agentsListFiles: (files: Files) => FunctionTool<UnknownContext, ListFilesParameters, ListFilesOutput>;
+declare const agentsGetFileMetadata: (files: Files) => FunctionTool<UnknownContext, GetFileMetadataParameters, GetFileMetadataOutput>;
+declare const agentsDownloadFile: (files: Files) => FunctionTool<UnknownContext, DownloadFileParameters, DownloadFileOutput>;
+declare const agentsGetFileUrl: (files: Files) => FunctionTool<UnknownContext, GetFileUrlParameters, GetFileUrlOutput>;
+declare const agentsUploadFile: (files: Files, {
+  needsApproval
+}?: {
+  needsApproval?: boolean;
+}) => FunctionTool<UnknownContext, UploadFileParameters, UploadFileOutput>;
+declare const agentsDeleteFile: (files: Files, {
+  needsApproval
+}?: {
+  needsApproval?: boolean;
+}) => FunctionTool<UnknownContext, DeleteFileParameters, DeleteFileOutput>;
+declare const agentsCopyFile: (files: Files, {
+  needsApproval
+}?: {
+  needsApproval?: boolean;
+}) => FunctionTool<UnknownContext, CopyFileParameters, CopyFileOutput>;
+declare const agentsSignUploadUrl: (files: Files, {
+  needsApproval
+}?: {
+  needsApproval?: boolean;
+}) => FunctionTool<UnknownContext, SignUploadUrlParameters, SignUploadUrlOutput>;
+interface AgentsFileTools {
+  copyFile: ReturnType<typeof agentsCopyFile>;
+  deleteFile: ReturnType<typeof agentsDeleteFile>;
+  downloadFile: ReturnType<typeof agentsDownloadFile>;
+  getFileMetadata: ReturnType<typeof agentsGetFileMetadata>;
+  getFileUrl: ReturnType<typeof agentsGetFileUrl>;
+  listFiles: ReturnType<typeof agentsListFiles>;
+  signUploadUrl: ReturnType<typeof agentsSignUploadUrl>;
+  uploadFile: ReturnType<typeof agentsUploadFile>;
+}
+type ReadOnlyAgentsFileTools = Pick<AgentsFileTools, FileReadToolName>;
+interface AgentsFileToolsOptions {
+  files: Files;
+  overrides?: Partial<Record<FileToolName, AgentsToolOverrides>>;
+  readOnly?: boolean;
+  requireApproval?: ApprovalConfig;
+}
+/**
+* Create a set of storage tools shaped for the OpenAI Agents SDK (`@openai/agents`).
+*
+* Returns a record keyed by tool name — spread `Object.values()` into
+* `new Agent({ tools })`. Write tools require approval by default.
+* @example
+* ```ts
+* import { Agent, run } from "@openai/agents";
+* import { Files } from "@visulima/storage";
+* import { S3Storage } from "@visulima/storage/provider/aws";
+* import { createAgentsFileTools } from "@visulima/storage/ai/openai";
+*
+* const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
+* const tools = createAgentsFileTools({ files });
+*
+* const agent = new Agent({
+*   instructions: "Help the user manage their files.",
+*   name: "Files agent",
+*   tools: Object.values(tools),
+* });
+*
+* const result = await run(agent, "List my files.");
+* ```
+*/
+declare function createAgentsFileTools(options: AgentsFileToolsOptions & {
+  readOnly: true;
+}): ReadOnlyAgentsFileTools;
+declare function createAgentsFileTools(options: AgentsFileToolsOptions & {
+  readOnly?: false | undefined;
+}): AgentsFileTools;
+declare function createAgentsFileTools(options: AgentsFileToolsOptions): AgentsFileTools | ReadOnlyAgentsFileTools;
+/**
+* A function-tool definition shaped for OpenAI's Responses API. Pass an
+* array of these to `openai.responses.create({ tools })`.
+*/
+interface ResponsesFunctionTool {
+  description: string;
+  name: string;
+  parameters: Record<string, unknown>;
+  strict: boolean;
+  type: "function";
+}
+/**
+* A function call emitted by the Responses API in `response.output[]`.
+*/
+interface FunctionCallItem {
+  arguments: string;
+  call_id: string;
+  name: string;
+  type: "function_call";
+}
+/**
+* A function-call output item to append to the next `responses.create`
+* input alongside the original `function_call` item.
+*/
+interface FunctionCallOutputItem {
+  call_id: string;
+  output: string;
+  type: "function_call_output";
+}
+interface ResponsesFileTools {
+  /**
+  * Function tool definitions. Pass directly to `openai.responses.create({ tools })`.
+  */
+  definitions: ResponsesFunctionTool[];
+  /**
+  * Execute a `function_call` item from the model's `response.output[]`.
+  * Returns a `function_call_output` item ready to push into the next turn's input.
+  *
+  * Approval is **not** enforced. Check {@link ResponsesFileTools.needsApproval}
+  * first if you want a human-in-the-loop gate.
+  */
+  execute: (call: FunctionCallItem) => Promise<FunctionCallOutputItem>;
+  /**
+  * Returns whether the named tool is approval-gated under this config.
+  * Read tools always return `false`. Unknown names return `false`.
+  */
+  needsApproval: (name: string) => boolean;
+}
+interface ResponsesFileToolsOptions {
+  files: Files;
+  overrides?: Partial<Record<FileToolName, ResponsesToolOverrides>>;
+  readOnly?: boolean;
+  requireApproval?: ApprovalConfig;
+}
+/**
+* Create a set of storage tools shaped for OpenAI's Responses API (`openai.responses.create`).
+* @example
+* ```ts
+* import OpenAI from "openai";
+* import { Files } from "@visulima/storage";
+* import { S3Storage } from "@visulima/storage/provider/aws";
+* import { createResponsesFileTools } from "@visulima/storage/ai/openai";
+*
+* const client = new OpenAI();
+* const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
+* const ft = createResponsesFileTools({ files });
+*
+* const input: any[] = [{ role: "user", content: "List my files." }];
+* while (true) {
+*   const res = await client.responses.create({ model: "gpt-4.1", input, tools: ft.definitions });
+*   const calls = res.output.filter((o) => o.type === "function_call");
+*   if (calls.length === 0) break;
+*   for (const call of calls) {
+*     if (ft.needsApproval(call.name)) {
+*       // surface approval UX, then continue or break
+*     }
+*     input.push(call, await ft.execute(call));
+*   }
+* }
+* ```
+*/
+declare const createResponsesFileTools: ({
+  files,
+  overrides,
+  readOnly,
+  requireApproval
+}: ResponsesFileToolsOptions) => ResponsesFileTools;
+export { type AgentsFileTools, type AgentsFileToolsOptions, type AgentsToolOverrides, type ApprovalConfig, type FileReadToolName, type FileToolName, type FunctionCallItem, type FunctionCallOutputItem, type ReadOnlyAgentsFileTools, type ResponsesFileTools, type ResponsesFileToolsOptions, type ResponsesFunctionTool, type ResponsesToolOverrides, agentsCopyFile, agentsDeleteFile, agentsDownloadFile, agentsGetFileMetadata, agentsGetFileUrl, agentsListFiles, agentsSignUploadUrl, agentsUploadFile, createAgentsFileTools, createResponsesFileTools };

package/dist/ai/openai/index.js

@@ -0,0 +1 @@
+import{agentsCopyFile as l,agentsDeleteFile as a,agentsDownloadFile as s,agentsGetFileMetadata as o,agentsGetFileUrl as n,agentsListFiles as i,agentsSignUploadUrl as g,agentsUploadFile as F,createAgentsFileTools as r}from"../../packem_shared/agentsCopyFile-Dl5iffdH.js";import{createResponsesFileTools as d}from"../../packem_shared/createResponsesFileTools-6Tvt2PNr.js";export{l as agentsCopyFile,a as agentsDeleteFile,s as agentsDownloadFile,o as agentsGetFileMetadata,n as agentsGetFileUrl,i as agentsListFiles,g as agentsSignUploadUrl,F as agentsUploadFile,r as createAgentsFileTools,d as createResponsesFileTools};

package/dist/ai/tanstack/index.d.ts

@@ -0,0 +1,115 @@
+import { F as Files } from "../../packem_shared/files.d-CH0iLBNC.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import { T as TOOL_SCHEMAS, c as FileReadToolName, F as FileToolName, A as ApprovalConfig } from "../../packem_shared/approval.d-CMAYH9GF.js";
+export type { d as FileWriteToolName } from "../../packem_shared/approval.d-CMAYH9GF.js";
+import { ServerTool } from '@tanstack/ai';
+import "../../packem_shared/storage.d-CEM1upWM.js";
+import 'zod';
+/**
+* Common options accepted by every write-tool factory.
+*/
+interface ToolOptions {
+  needsApproval?: boolean;
+}
+/**
+* Per-tool overrides for customizing TanStack AI `ServerTool` properties
+* without changing the underlying implementation. Core properties
+* (`execute`, `inputSchema`, `outputSchema`, `__toolSide`) are intentionally
+* excluded — those drive the tool's behavior and contract.
+*/
+type ToolOverrides = Partial<Pick<ServerTool, "description" | "lazy" | "metadata" | "needsApproval">>;
+type ListFilesParameters = typeof TOOL_SCHEMAS.listFiles.input;
+type GetFileMetadataParameters = typeof TOOL_SCHEMAS.getFileMetadata.input;
+type DownloadFileParameters = typeof TOOL_SCHEMAS.downloadFile.input;
+type GetFileUrlParameters = typeof TOOL_SCHEMAS.getFileUrl.input;
+type UploadFileParameters = typeof TOOL_SCHEMAS.uploadFile.input;
+type DeleteFileParameters = typeof TOOL_SCHEMAS.deleteFile.input;
+type CopyFileParameters = typeof TOOL_SCHEMAS.copyFile.input;
+type SignUploadUrlParameters = typeof TOOL_SCHEMAS.signUploadUrl.input;
+declare const listFiles: (files: Files) => ServerTool<ListFilesParameters, never, "listFiles">;
+declare const getFileMetadata: (files: Files) => ServerTool<GetFileMetadataParameters, never, "getFileMetadata">;
+declare const downloadFile: (files: Files) => ServerTool<DownloadFileParameters, never, "downloadFile">;
+declare const getFileUrl: (files: Files) => ServerTool<GetFileUrlParameters, never, "getFileUrl">;
+declare const uploadFile: (files: Files, {
+  needsApproval
+}?: ToolOptions) => ServerTool<UploadFileParameters, never, "uploadFile">;
+declare const deleteFile: (files: Files, {
+  needsApproval
+}?: ToolOptions) => ServerTool<DeleteFileParameters, never, "deleteFile">;
+declare const copyFile: (files: Files, {
+  needsApproval
+}?: ToolOptions) => ServerTool<CopyFileParameters, never, "copyFile">;
+declare const signUploadUrl: (files: Files, {
+  needsApproval
+}?: ToolOptions) => ServerTool<SignUploadUrlParameters, never, "signUploadUrl">;
+interface TanstackFileToolsOptions {
+  /**
+  * The configured `Files` instance the tools will operate against.
+  * Each tool delegates to the methods on this instance.
+  */
+  files: Files;
+  /**
+  * Per-tool overrides for customizing tool behavior (description,
+  * needsApproval, metadata) without changing the underlying implementation.
+  * `execute` and `inputSchema` cannot be overridden.
+  */
+  overrides?: Partial<Record<FileToolName, ToolOverrides>>;
+  /**
+  * When `true`, write tools (`uploadFile`, `deleteFile`, `copyFile`,
+  * `signUploadUrl`) are omitted entirely. The model cannot mutate the
+  * bucket regardless of approval configuration.
+  */
+  readOnly?: boolean;
+  /**
+  * Approval gating for write tools. Defaults to `true` (all writes
+  * require approval). See {@link ApprovalConfig}.
+  */
+  requireApproval?: ApprovalConfig;
+}
+interface TanstackFileTools {
+  copyFile: ReturnType<typeof copyFile>;
+  deleteFile: ReturnType<typeof deleteFile>;
+  downloadFile: ReturnType<typeof downloadFile>;
+  getFileMetadata: ReturnType<typeof getFileMetadata>;
+  getFileUrl: ReturnType<typeof getFileUrl>;
+  listFiles: ReturnType<typeof listFiles>;
+  signUploadUrl: ReturnType<typeof signUploadUrl>;
+  uploadFile: ReturnType<typeof uploadFile>;
+}
+type ReadOnlyTanstackFileTools = Pick<TanstackFileTools, FileReadToolName>;
+/**
+* Create a set of visulima/storage tools for TanStack AI.
+*
+* Each entry is a `ServerTool` built via `toolDefinition(...).server(...)`,
+* ready to be passed to `chat({ tools: [...] })` or registered with a
+* `ToolRegistry`. Write operations require user approval by default;
+* control globally or per-tool via `requireApproval`, or strip writes
+* entirely with `readOnly: true`.
+* @example
+* ```ts
+* import { Files } from "@visulima/storage";
+* import { S3Storage } from "@visulima/storage/provider/aws";
+* import { createTanstackFileTools } from "@visulima/storage/ai/tanstack";
+* import { chat } from "@tanstack/ai";
+*
+* const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
+* const tools = createTanstackFileTools({ files });
+*
+* const stream = chat({
+*   adapter,
+*   messages,
+*   tools: Object.values(tools),
+* });
+* ```
+*/
+declare function createTanstackFileTools(options: TanstackFileToolsOptions & {
+  readOnly: true;
+}): ReadOnlyTanstackFileTools;
+declare function createTanstackFileTools(options: TanstackFileToolsOptions & {
+  readOnly?: false | undefined;
+}): TanstackFileTools;
+declare function createTanstackFileTools(options: TanstackFileToolsOptions): ReadOnlyTanstackFileTools | TanstackFileTools;
+export { type ApprovalConfig, type FileReadToolName, type FileToolName, ReadOnlyTanstackFileTools, TanstackFileTools, TanstackFileToolsOptions, type ToolOptions, type ToolOverrides, copyFile, createTanstackFileTools, deleteFile, downloadFile, getFileMetadata, getFileUrl, listFiles, signUploadUrl, uploadFile };

package/dist/ai/tanstack/index.js

@@ -0,0 +1 @@
+import{r as p}from"../../packem_shared/approval-fVHwBp7u.js";import{W as d}from"../../packem_shared/executors-BDzMjc4y.js";import{uploadFile as F,signUploadUrl as c,listFiles as f,getFileUrl as g,getFileMetadata as U,downloadFile as m,deleteFile as u,copyFile as O}from"../../packem_shared/copyFile-BUPezT_c.js";function j({files:e,overrides:t,readOnly:s=!1,requireApproval:n=!0}){const o=l=>({needsApproval:p(l,n)}),i={copyFile:O(e,o("copyFile")),deleteFile:u(e,o("deleteFile")),downloadFile:m(e),getFileMetadata:U(e),getFileUrl:g(e),listFiles:f(e),signUploadUrl:c(e,o("signUploadUrl")),uploadFile:F(e,o("uploadFile"))};if(t){for(const[l,r]of Object.entries(t))if(l in i&&r){const a=l;Object.assign(i,{[a]:{...i[a],...r}})}}return s?Object.fromEntries(Object.entries(i).filter(([l])=>!d.has(l))):i}export{O as copyFile,j as createTanstackFileTools,u as deleteFile,m as downloadFile,U as getFileMetadata,g as getFileUrl,f as listFiles,c as signUploadUrl,F as uploadFile};

package/dist/handler/http/fetch/index.d.ts

@@ -1,4 +1,303 @@
-export { default as Multipart } from "../../multipart/multipart-fetch.d.ts";
-export { default as Rest } from "../../rest/rest-fetch.d.ts";
-export { Tus, TUS_RESUMABLE, TUS_VERSION } from "../../tus/tus-fetch.d.ts";
-export type { AsyncHandler, BaseHandler, Handlers, MethodHandler, RequestEvent, UploadErrorEvent, UploadEvent, UploadOptions } from "../../types.d.ts";
+import { U as UploadFile, m as UploadResponse } from "../../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import { H as Handlers, R as ResponseFile, a as ResponseList, U as UploadOptions } from "../../../packem_shared/types.d-CggTCgXr.js";
+export type { A as AsyncHandler, B as BaseHandler, M as MethodHandler, b as RequestEvent, c as UploadErrorEvent, d as UploadEvent } from "../../../packem_shared/types.d-CggTCgXr.js";
+import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-DLzKE54M.js";
+export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-DLzKE54M.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-Quf4ai47.js";
+import "../../../packem_shared/types.d-CrUWY4On.js";
+/**
+* Base handler for Web API Fetch platform (Request/Response).
+* Extends BaseHandlerCore with Fetch-specific request/response handling.
+* @template TFile The file type used by this handler.
+*/
+declare abstract class BaseHandlerFetch<TFile extends UploadFile> extends BaseHandlerCore<TFile> {
+  /**
+  * Limiting enabled HTTP method handler.
+  */
+  static readonly methods: Handlers[];
+  /**
+  * Map of registered HTTP method handlers.
+  */
+  protected registeredHandlers: Map<string, (request: Request) => Promise<ResponseFile<TFile> | ResponseList<TFile>>>;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Gets the registered handlers map.
+  * @returns Map of registered handlers.
+  */
+  get handlers(): Map<string, (request: Request) => Promise<ResponseFile<TFile> | ResponseList<TFile>>>;
+  /**
+  * Handles Web API Fetch requests (for Hono, Cloudflare Workers, etc.).
+  * @param request Web API Request object.
+  * @returns Promise resolving to Web API Response.
+  */
+  fetch(request: Request): Promise<globalThis.Response>;
+  /**
+  * Compose and register HTTP method handlers.
+  * Subclasses should override this to register their specific handlers.
+  */
+  protected abstract compose(): void;
+  /**
+  * Handle the response from handlers for fetch requests and convert to Web API Response.
+  * @param request Web API Request object
+  * @param file Response file or list from handler
+  * @returns Promise resolving to Web API Response object
+  */
+  protected handleFetchResponse(request: Request, file: ResponseFile<TFile> | ResponseList<TFile>): Promise<globalThis.Response>;
+  /**
+  * Convert headers to Web API Headers format by flattening arrays and converting to strings.
+  * @param headers Headers object with potentially array values
+  * @returns Headers object with all values as strings
+  */
+  protected convertHeaders(headers: Record<string, number | string | string[]>): Record<string, string>;
+  /**
+  * Create Web API Response from UploadResponse object.
+  * @param uploadResponse Upload response containing body, headers, and status code
+  * @returns Web API Response object
+  */
+  protected createResponse(uploadResponse: UploadResponse): globalThis.Response;
+  /**
+  * Create error Response from Error object with appropriate status code and message.
+  * @param error Error object to convert to HTTP error response
+  * @returns Web API Response object with error details
+  */
+  protected createErrorResponse(error: Error): Promise<globalThis.Response>;
+  /**
+  * Build file URL from request and file data.
+  * @param request Web API Request object
+  * @param file File object containing ID and content type
+  * @returns Constructed file URL with extension based on content type
+  */
+  protected buildFileUrl(request: Request, file: TFile): string;
+  /**
+  * Negotiates content type based on Accept header and supported formats.
+  * @param request Web API Request object containing Accept header.
+  * @param supportedTypes Array of supported MIME types to match against.
+  * @returns Best matching content type or undefined if no match found.
+  */
+  negotiateContentType(request: Request, supportedTypes: string[]): string | undefined;
+}
+/**
+* Multipart/form-data upload handler (Web API Fetch version).
+* @example
+* ```ts
+* const multipart = new MultipartFetch({
+*   storage,
+*   maxFileSize: 100 * 1024 * 1024, // 100MB
+* });
+*
+* // Use with Hono, Cloudflare Workers, etc.
+* app.all('/files/*', async (c) => {
+*   return multipart.fetch(c.req.raw);
+* });
+* ```
+*/
+declare class Multipart<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
+  /**
+  * Limiting enabled http method handler
+  */
+  static override readonly methods: Handlers[];
+  private readonly multipartBase;
+  /**
+  * Maximum file size allowed for multipart uploads
+  */
+  private maxFileSize;
+  /**
+  * Maximum header size allowed for multipart parser
+  */
+  private maxHeaderSize;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Handles multipart/form-data POST requests for file uploads.
+  * @param request Web API Request containing multipart data.
+  * @returns Promise resolving to ResponseFile with upload result.
+  */
+  post(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Delete an uploaded file.
+  * @param request Web API Request with file ID
+  * @returns Promise resolving to ResponseFile with deletion result
+  */
+  delete(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Handle OPTIONS requests with CORS headers.
+  * @param _request Web API Request (unused)
+  * @returns Promise resolving to ResponseFile with CORS headers
+  */
+  options(_request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Retrieves a file or list of files based on the request path.
+  * Delegates to BaseHandlerFetch.fetch() method.
+  * @param _request Web API Request
+  * @returns Promise resolving to Web API Response
+  */
+  get(_request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Compose and register HTTP method handlers.
+  */
+  protected compose(): void;
+}
+/**
+* REST API handler for direct binary file uploads (Web API Fetch version).
+*
+* This handler provides a clean REST interface for file operations using Web API Request/Response:
+* - POST: Create a new file with raw binary data or initialize chunked upload
+* - PUT: Create or update a file (requires ID in URL)
+* - PATCH: Upload chunks for chunked uploads (requires ID in URL)
+* - GET: Retrieve a file or list files
+* - DELETE: Delete a file (single) or multiple files (via ?ids=id1,id2 or JSON body)
+* - HEAD: Get file metadata and upload progress
+* - OPTIONS: CORS preflight
+* @example
+* ```ts
+* const rest = new RestFetch({
+*   storage,
+* });
+*
+* // Use with Hono, Cloudflare Workers, etc.
+* app.all('/files/*', async (c) => {
+*   return rest.fetch(c.req.raw);
+* });
+* ```
+*/
+declare class RestFetch<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
+  /**
+  * Limiting enabled http method handler
+  */
+  static override readonly methods: Handlers[];
+  private readonly restBase;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Compose and register HTTP method handlers.
+  */
+  protected compose(): void;
+  /**
+  * Creates a new file via POST request with raw binary data.
+  * Supports both full file uploads and chunked upload initialization.
+  * @param request Web API Request with file data.
+  * @returns Promise resolving to ResponseFile with upload result.
+  */
+  post(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Create or update a file via PUT request.
+  * Requires file ID in the URL path.
+  * @param request Web API Request with file ID and data
+  * @returns Promise resolving to ResponseFile with upload result
+  */
+  put(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Delete an uploaded file or multiple files.
+  * Supports single file (ID in URL) or batch delete (via ?ids=id1,id2 or JSON body).
+  * @param request Web API Request with file ID(s)
+  * @returns Promise resolving to ResponseFile (single) or ResponseList (batch) with deletion result
+  */
+  delete(request: Request): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+  /**
+  * Uploads a chunk via PATCH request for chunked uploads.
+  * Headers required: X-Chunk-Offset (byte offset), Content-Length (chunk size).
+  * Optional: X-Chunk-Checksum (SHA256 checksum for validation).
+  * @param request Web API Request with chunk data.
+  * @returns Promise resolving to ResponseFile with upload progress.
+  */
+  patch(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Get file metadata via HEAD request.
+  * For chunked uploads, also returns upload progress information.
+  * @param request Web API Request with file ID
+  * @returns Promise resolving to ResponseFile with metadata headers
+  */
+  head(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Handle OPTIONS requests with REST API capabilities.
+  * @param _request Web API Request
+  * @returns Promise resolving to ResponseFile with CORS headers
+  */
+  options(_request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Retrieves a file or list of files based on the request path.
+  * Delegates to BaseHandlerFetch.fetch() method.
+  * @param _request Web API Request
+  * @returns Promise resolving to Web API Response
+  */
+  get(_request: Request): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+}
+/**
+* TUS resumable upload protocol handler (Web API Fetch version).
+*
+* [tus resumable upload protocol](https://github.com/tus/tus-resumable-upload-protocol/blob/master/protocol.md)
+* @example
+* ```ts
+* const tus = new TusFetch({storage});
+*
+* // Use with Hono, Cloudflare Workers, etc.
+* app.all('/files/*', async (c) => {
+*   return tus.fetch(c.req.raw);
+* });
+* ```
+*/
+declare class Tus<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
+  /**
+  * Limiting enabled http method handler
+  */
+  static override readonly methods: Handlers[];
+  private readonly tusBase;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Web API fetch entrypoint. Wraps the base implementation to ensure every TUS
+  * response — success and error alike — carries the `Tus-Resumable` header,
+  * which the protocol requires on all responses.
+  */
+  override fetch(request: Request): Promise<globalThis.Response>;
+  /**
+  * Handle OPTIONS requests with TUS protocol capabilities.
+  * @returns Promise resolving to ResponseFile with TUS headers
+  */
+  options(): Promise<ResponseFile<TFile>>;
+  /**
+  * Creates a new TUS upload and optionally starts uploading data.
+  * @param request Web API Request with TUS headers.
+  * @returns Promise resolving to ResponseFile with upload location and offset.
+  */
+  post(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Write a chunk of data to an existing TUS upload.
+  * @param request Web API Request with chunk data and TUS headers
+  * @returns Promise resolving to ResponseFile with updated offset
+  */
+  patch(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Get current upload offset and metadata for TUS resumable uploads.
+  * @param request Web API Request with upload ID
+  * @returns Promise resolving to ResponseFile with upload-offset and metadata headers
+  */
+  head(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Get TUS upload metadata and current status.
+  * @param request Web API Request with upload ID
+  * @returns Promise resolving to ResponseFile with file metadata as JSON
+  */
+  get(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Delete a TUS upload and its associated data.
+  * @param request Web API Request with upload ID
+  * @returns Promise resolving to ResponseFile with deletion confirmation
+  */
+  delete(request: Request): Promise<ResponseFile<TFile>>;
+  /**
+  * Compose and register HTTP method handlers.
+  */
+  protected compose(): void;
+  /**
+  * Build file URL for TUS uploads (without file extension).
+  * @param requestUrl Request URL string
+  * @param file File object containing ID
+  * @returns Constructed file URL for TUS protocol
+  */
+  protected buildFileUrlForTus(requestUrl: string, file: TFile): string;
+}
+export { type Handlers, Multipart, RestFetch as Rest, Tus, type UploadOptions };

package/dist/handler/http/fetch/index.js

@@ -1,4 +1 @@
-export { default as Multipart } from '../../../packem_shared/Multipart-D2ryPMjD.js';
-export { default as Rest } from '../../../packem_shared/Rest-DjwU3puo.js';
-export { Tus } from '../../../packem_shared/Tus-DFVlZHaX.js';
-export { TUS_RESUMABLE, TUS_VERSION } from '../../../packem_shared/TUS_RESUMABLE-Dtfsffnj.js';
+import{default as o}from"../../../packem_shared/Multipart-C4GpuHMU.js";import{default as f}from"../../../packem_shared/Rest-ymPCZkKR.js";import{Tus as p}from"../../../packem_shared/Tus-v6jzkaIO.js";import{TUS_RESUMABLE as s,TUS_VERSION as u}from"../../../packem_shared/TUS_RESUMABLE-CyTSRvPU.js";export{o as Multipart,f as Rest,s as TUS_RESUMABLE,u as TUS_VERSION,p as Tus};