@supabase/storage-js 2.91.1 → 2.91.2

package/dist/index.cjs

@@ -1,20 +1,36 @@
 let iceberg_js = require("iceberg-js");
 
-//#region src/lib/errors.ts
+//#region src/lib/common/errors.ts
+/**
+* Base error class for all Storage errors
+* Supports both 'storage' and 'vectors' namespaces
+*/
 var StorageError = class extends Error {
-	constructor(message) {
+	constructor(message, namespace = "storage", status, statusCode) {
 		super(message);
 		this.__isStorageError = true;
-		this.name = "StorageError";
+		this.namespace = namespace;
+		this.name = namespace === "vectors" ? "StorageVectorsError" : "StorageError";
+		this.status = status;
+		this.statusCode = statusCode;
 	}
 };
+/**
+* Type guard to check if an error is a StorageError
+* @param error - The error to check
+* @returns True if the error is a StorageError
+*/
 function isStorageError(error) {
 	return typeof error === "object" && error !== null && "__isStorageError" in error;
 }
+/**
+* API error returned from Storage service
+* Includes HTTP status code and service-specific error code
+*/
 var StorageApiError = class extends StorageError {
-	constructor(message, status, statusCode) {
-		super(message);
-		this.name = "StorageApiError";
+	constructor(message, status, statusCode, namespace = "storage") {
+		super(message, namespace, status, statusCode);
+		this.name = namespace === "vectors" ? "StorageVectorsApiError" : "StorageApiError";
 		this.status = status;
 		this.statusCode = statusCode;
 	}
@@ -27,23 +43,105 @@ var StorageApiError = class extends StorageError {
 		};
 	}
 };
+/**
+* Unknown error that doesn't match expected error patterns
+* Wraps the original error for debugging
+*/
 var StorageUnknownError = class extends StorageError {
-	constructor(message, originalError) {
-		super(message);
-		this.name = "StorageUnknownError";
+	constructor(message, originalError, namespace = "storage") {
+		super(message, namespace);
+		this.name = namespace === "vectors" ? "StorageVectorsUnknownError" : "StorageUnknownError";
 		this.originalError = originalError;
 	}
 };
+/**
+* @deprecated Use StorageError with namespace='vectors' instead
+* Alias for backward compatibility with existing vector storage code
+*/
+var StorageVectorsError = class extends StorageError {
+	constructor(message) {
+		super(message, "vectors");
+	}
+};
+/**
+* Type guard to check if an error is a StorageVectorsError
+* @param error - The error to check
+* @returns True if the error is a StorageVectorsError
+*/
+function isStorageVectorsError(error) {
+	return isStorageError(error) && error["namespace"] === "vectors";
+}
+/**
+* @deprecated Use StorageApiError with namespace='vectors' instead
+* Alias for backward compatibility with existing vector storage code
+*/
+var StorageVectorsApiError = class extends StorageApiError {
+	constructor(message, status, statusCode) {
+		super(message, status, statusCode, "vectors");
+	}
+};
+/**
+* @deprecated Use StorageUnknownError with namespace='vectors' instead
+* Alias for backward compatibility with existing vector storage code
+*/
+var StorageVectorsUnknownError = class extends StorageUnknownError {
+	constructor(message, originalError) {
+		super(message, originalError, "vectors");
+	}
+};
+/**
+* Error codes specific to S3 Vectors API
+* Maps AWS service errors to application-friendly error codes
+*/
+let StorageVectorsErrorCode = /* @__PURE__ */ function(StorageVectorsErrorCode$1) {
+	/** Internal server fault (HTTP 500) */
+	StorageVectorsErrorCode$1["InternalError"] = "InternalError";
+	/** Resource already exists / conflict (HTTP 409) */
+	StorageVectorsErrorCode$1["S3VectorConflictException"] = "S3VectorConflictException";
+	/** Resource not found (HTTP 404) */
+	StorageVectorsErrorCode$1["S3VectorNotFoundException"] = "S3VectorNotFoundException";
+	/** Delete bucket while not empty (HTTP 400) */
+	StorageVectorsErrorCode$1["S3VectorBucketNotEmpty"] = "S3VectorBucketNotEmpty";
+	/** Exceeds bucket quota/limit (HTTP 400) */
+	StorageVectorsErrorCode$1["S3VectorMaxBucketsExceeded"] = "S3VectorMaxBucketsExceeded";
+	/** Exceeds index quota/limit (HTTP 400) */
+	StorageVectorsErrorCode$1["S3VectorMaxIndexesExceeded"] = "S3VectorMaxIndexesExceeded";
+	return StorageVectorsErrorCode$1;
+}({});
 
 //#endregion
-//#region src/lib/helpers.ts
-const resolveFetch$1 = (customFetch) => {
+//#region src/lib/common/helpers.ts
+/**
+* Resolves the fetch implementation to use
+* Uses custom fetch if provided, otherwise uses native fetch
+*
+* @param customFetch - Optional custom fetch implementation
+* @returns Resolved fetch function
+*/
+const resolveFetch = (customFetch) => {
 	if (customFetch) return (...args) => customFetch(...args);
 	return (...args) => fetch(...args);
 };
-const resolveResponse$1 = () => {
-	return Response;
+/**
+* Determine if input is a plain object
+* An object is plain if it's created by either {}, new Object(), or Object.create(null)
+*
+* @param value - Value to check
+* @returns True if value is a plain object
+* @source https://github.com/sindresorhus/is-plain-obj
+*/
+const isPlainObject = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
 };
+/**
+* Recursively converts object keys from snake_case to camelCase
+* Used for normalizing API responses
+*
+* @param item - Object to convert
+* @returns Converted object with camelCase keys
+*/
 const recursiveToCamel = (item) => {
 	if (Array.isArray(item)) return item.map((el) => recursiveToCamel(el));
 	else if (typeof item === "function" || item !== Object(item)) return item;
@@ -55,16 +153,6 @@ const recursiveToCamel = (item) => {
 	return result;
 };
 /**
-* Determine if input is a plain object
-* An object is plain if it's created by either {}, new Object(), or Object.create(null)
-* source: https://github.com/sindresorhus/is-plain-obj
-*/
-const isPlainObject$1 = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-};
-/**
 * Validates if a given bucket name is valid according to Supabase Storage API rules
 * Mirrors backend validation from: storage/src/storage/limits.ts:isValidBucketName()
 *
@@ -154,58 +242,193 @@ function _objectSpread2(e) {
 }
 
 //#endregion
-//#region src/lib/fetch.ts
-const _getErrorMessage$1 = (err) => {
+//#region src/lib/common/fetch.ts
+/**
+* Extracts error message from various error response formats
+* @param err - Error object from API
+* @returns Human-readable error message
+*/
+const _getErrorMessage = (err) => {
 	var _err$error;
 	return err.msg || err.message || err.error_description || (typeof err.error === "string" ? err.error : (_err$error = err.error) === null || _err$error === void 0 ? void 0 : _err$error.message) || JSON.stringify(err);
 };
-const handleError$1 = async (error, reject, options) => {
-	if (error instanceof await resolveResponse$1() && !(options === null || options === void 0 ? void 0 : options.noResolveJson)) error.json().then((err) => {
-		const status = error.status || 500;
-		const statusCode = (err === null || err === void 0 ? void 0 : err.statusCode) || status + "";
-		reject(new StorageApiError(_getErrorMessage$1(err), status, statusCode));
-	}).catch((err) => {
-		reject(new StorageUnknownError(_getErrorMessage$1(err), err));
-	});
-	else reject(new StorageUnknownError(_getErrorMessage$1(error), error));
+/**
+* Handles fetch errors and converts them to Storage error types
+* @param error - The error caught from fetch
+* @param reject - Promise rejection function
+* @param options - Fetch options that may affect error handling
+* @param namespace - Error namespace ('storage' or 'vectors')
+*/
+const handleError = async (error, reject, options, namespace) => {
+	if (error && typeof error === "object" && "status" in error && "ok" in error && typeof error.status === "number" && !(options === null || options === void 0 ? void 0 : options.noResolveJson)) {
+		const responseError = error;
+		const status = responseError.status || 500;
+		if (typeof responseError.json === "function") responseError.json().then((err) => {
+			const statusCode = (err === null || err === void 0 ? void 0 : err.statusCode) || (err === null || err === void 0 ? void 0 : err.code) || status + "";
+			reject(new StorageApiError(_getErrorMessage(err), status, statusCode, namespace));
+		}).catch(() => {
+			if (namespace === "vectors") {
+				const statusCode = status + "";
+				reject(new StorageApiError(responseError.statusText || `HTTP ${status} error`, status, statusCode, namespace));
+			} else {
+				const statusCode = status + "";
+				reject(new StorageApiError(responseError.statusText || `HTTP ${status} error`, status, statusCode, namespace));
+			}
+		});
+		else {
+			const statusCode = status + "";
+			reject(new StorageApiError(responseError.statusText || `HTTP ${status} error`, status, statusCode, namespace));
+		}
+	} else reject(new StorageUnknownError(_getErrorMessage(error), error, namespace));
 };
-const _getRequestParams$1 = (method, options, parameters, body) => {
+/**
+* Builds request parameters for fetch calls
+* @param method - HTTP method
+* @param options - Custom fetch options
+* @param parameters - Additional fetch parameters like AbortSignal
+* @param body - Request body (will be JSON stringified if plain object)
+* @returns Complete fetch request parameters
+*/
+const _getRequestParams = (method, options, parameters, body) => {
 	const params = {
 		method,
 		headers: (options === null || options === void 0 ? void 0 : options.headers) || {}
 	};
-	if (method === "GET" || !body) return params;
-	if (isPlainObject$1(body)) {
+	if (method === "GET" || method === "HEAD" || !body) return _objectSpread2(_objectSpread2({}, params), parameters);
+	if (isPlainObject(body)) {
 		params.headers = _objectSpread2({ "Content-Type": "application/json" }, options === null || options === void 0 ? void 0 : options.headers);
 		params.body = JSON.stringify(body);
 	} else params.body = body;
 	if (options === null || options === void 0 ? void 0 : options.duplex) params.duplex = options.duplex;
 	return _objectSpread2(_objectSpread2({}, params), parameters);
 };
-async function _handleRequest$1(fetcher, method, url, options, parameters, body) {
+/**
+* Internal request handler that wraps fetch with error handling
+* @param fetcher - Fetch function to use
+* @param method - HTTP method
+* @param url - Request URL
+* @param options - Custom fetch options
+* @param parameters - Additional fetch parameters
+* @param body - Request body
+* @param namespace - Error namespace ('storage' or 'vectors')
+* @returns Promise with parsed response or error
+*/
+async function _handleRequest(fetcher, method, url, options, parameters, body, namespace) {
 	return new Promise((resolve, reject) => {
-		fetcher(url, _getRequestParams$1(method, options, parameters, body)).then((result) => {
+		fetcher(url, _getRequestParams(method, options, parameters, body)).then((result) => {
 			if (!result.ok) throw result;
 			if (options === null || options === void 0 ? void 0 : options.noResolveJson) return result;
+			if (namespace === "vectors") {
+				const contentType = result.headers.get("content-type");
+				if (!contentType || !contentType.includes("application/json")) return {};
+			}
 			return result.json();
-		}).then((data) => resolve(data)).catch((error) => handleError$1(error, reject, options));
+		}).then((data) => resolve(data)).catch((error) => handleError(error, reject, options, namespace));
 	});
 }
-async function get(fetcher, url, options, parameters) {
-	return _handleRequest$1(fetcher, "GET", url, options, parameters);
-}
-async function post$1(fetcher, url, body, options, parameters) {
-	return _handleRequest$1(fetcher, "POST", url, options, parameters, body);
-}
-async function put(fetcher, url, body, options, parameters) {
-	return _handleRequest$1(fetcher, "PUT", url, options, parameters, body);
-}
-async function head(fetcher, url, options, parameters) {
-	return _handleRequest$1(fetcher, "HEAD", url, _objectSpread2(_objectSpread2({}, options), {}, { noResolveJson: true }), parameters);
-}
-async function remove(fetcher, url, body, options, parameters) {
-	return _handleRequest$1(fetcher, "DELETE", url, options, parameters, body);
+/**
+* Creates a fetch API with the specified namespace
+* @param namespace - Error namespace ('storage' or 'vectors')
+* @returns Object with HTTP method functions
+*/
+function createFetchApi(namespace = "storage") {
+	return {
+		get: async (fetcher, url, options, parameters) => {
+			return _handleRequest(fetcher, "GET", url, options, parameters, void 0, namespace);
+		},
+		post: async (fetcher, url, body, options, parameters) => {
+			return _handleRequest(fetcher, "POST", url, options, parameters, body, namespace);
+		},
+		put: async (fetcher, url, body, options, parameters) => {
+			return _handleRequest(fetcher, "PUT", url, options, parameters, body, namespace);
+		},
+		head: async (fetcher, url, options, parameters) => {
+			return _handleRequest(fetcher, "HEAD", url, _objectSpread2(_objectSpread2({}, options), {}, { noResolveJson: true }), parameters, void 0, namespace);
+		},
+		remove: async (fetcher, url, body, options, parameters) => {
+			return _handleRequest(fetcher, "DELETE", url, options, parameters, body, namespace);
+		}
+	};
 }
+const defaultApi = createFetchApi("storage");
+const { get, post, put, head, remove } = defaultApi;
+
+//#endregion
+//#region src/lib/common/BaseApiClient.ts
+/**
+* @ignore
+* Base API client class for all Storage API classes
+* Provides common infrastructure for error handling and configuration
+*
+* @typeParam TError - The error type (StorageError or subclass)
+*/
+var BaseApiClient = class {
+	/**
+	* Creates a new BaseApiClient instance
+	* @param url - Base URL for API requests
+	* @param headers - Default headers for API requests
+	* @param fetch - Optional custom fetch implementation
+	* @param namespace - Error namespace ('storage' or 'vectors')
+	*/
+	constructor(url, headers = {}, fetch$1, namespace = "storage") {
+		this.shouldThrowOnError = false;
+		this.url = url;
+		this.headers = headers;
+		this.fetch = resolveFetch(fetch$1);
+		this.namespace = namespace;
+	}
+	/**
+	* Enable throwing errors instead of returning them.
+	* When enabled, errors are thrown instead of returned in { data, error } format.
+	*
+	* @returns this - For method chaining
+	*/
+	throwOnError() {
+		this.shouldThrowOnError = true;
+		return this;
+	}
+	/**
+	* Handles API operation with standardized error handling
+	* Eliminates repetitive try-catch blocks across all API methods
+	*
+	* This wrapper:
+	* 1. Executes the operation
+	* 2. Returns { data, error: null } on success
+	* 3. Returns { data: null, error } on failure (if shouldThrowOnError is false)
+	* 4. Throws error on failure (if shouldThrowOnError is true)
+	*
+	* @typeParam T - The expected data type from the operation
+	* @param operation - Async function that performs the API call
+	* @returns Promise with { data, error } tuple
+	*
+	* @example
+	* ```typescript
+	* async listBuckets() {
+	*   return this.handleOperation(async () => {
+	*     return await get(this.fetch, `${this.url}/bucket`, {
+	*       headers: this.headers,
+	*     })
+	*   })
+	* }
+	* ```
+	*/
+	async handleOperation(operation) {
+		var _this = this;
+		try {
+			return {
+				data: await operation(),
+				error: null
+			};
+		} catch (error) {
+			if (_this.shouldThrowOnError) throw error;
+			if (isStorageError(error)) return {
+				data: null,
+				error
+			};
+			throw error;
+		}
+	}
+};
 
 //#endregion
 //#region src/packages/StreamDownloadBuilder.ts
@@ -295,22 +518,10 @@ const DEFAULT_FILE_OPTIONS = {
 	contentType: "text/plain;charset=UTF-8",
 	upsert: false
 };
-var StorageFileApi = class {
+var StorageFileApi = class extends BaseApiClient {
 	constructor(url, headers = {}, bucketId, fetch$1) {
-		this.shouldThrowOnError = false;
-		this.url = url;
-		this.headers = headers;
+		super(url, headers, fetch$1, "storage");
 		this.bucketId = bucketId;
-		this.fetch = resolveFetch$1(fetch$1);
-	}
-	/**
-	* Enable throwing errors instead of returning them.
-	*
-	* @category File Buckets
-	*/
-	throwOnError() {
-		this.shouldThrowOnError = true;
-		return this;
 	}
 	/**
 	* Uploads a file to an existing bucket or replaces an existing file at the specified path with a new one.
@@ -321,7 +532,7 @@ var StorageFileApi = class {
 	*/
 	async uploadOrUpdate(method, path, fileBody, fileOptions) {
 		var _this = this;
-		try {
+		return _this.handleOperation(async () => {
 			let body;
 			const options = _objectSpread2(_objectSpread2({}, DEFAULT_FILE_OPTIONS), fileOptions);
 			let headers = _objectSpread2(_objectSpread2({}, _this.headers), method === "POST" && { "x-upsert": String(options.upsert) });
@@ -345,23 +556,13 @@ var StorageFileApi = class {
 			if (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.headers) headers = _objectSpread2(_objectSpread2({}, headers), fileOptions.headers);
 			const cleanPath = _this._removeEmptyFolders(path);
 			const _path = _this._getFinalPath(cleanPath);
-			const data = await (method == "PUT" ? put : post$1)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread2({ headers }, (options === null || options === void 0 ? void 0 : options.duplex) ? { duplex: options.duplex } : {}));
+			const data = await (method == "PUT" ? put : post)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread2({ headers }, (options === null || options === void 0 ? void 0 : options.duplex) ? { duplex: options.duplex } : {}));
 			return {
-				data: {
-					path: cleanPath,
-					id: data.Id,
-					fullPath: data.Key
-				},
-				error: null
-			};
-		} catch (error) {
-			if (_this.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
+				path: cleanPath,
+				id: data.Id,
+				fullPath: data.Key
 			};
-			throw error;
-		}
+		});
 	}
 	/**
 	* Uploads a file to an existing bucket.
@@ -447,7 +648,7 @@ var StorageFileApi = class {
 		const _path = _this3._getFinalPath(cleanPath);
 		const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
 		url.searchParams.set("token", token);
-		try {
+		return _this3.handleOperation(async () => {
 			let body;
 			const options = _objectSpread2({ upsert: DEFAULT_FILE_OPTIONS.upsert }, fileOptions);
 			const headers = _objectSpread2(_objectSpread2({}, _this3.headers), { "x-upsert": String(options.upsert) });
@@ -464,20 +665,10 @@ var StorageFileApi = class {
 				headers["content-type"] = options.contentType;
 			}
 			return {
-				data: {
-					path: cleanPath,
-					fullPath: (await put(_this3.fetch, url.toString(), body, { headers })).Key
-				},
-				error: null
-			};
-		} catch (error) {
-			if (_this3.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
+				path: cleanPath,
+				fullPath: (await put(_this3.fetch, url.toString(), body, { headers })).Key
 			};
-			throw error;
-		}
+		});
 	}
 	/**
 	* Creates a signed upload URL.
@@ -511,30 +702,20 @@ var StorageFileApi = class {
 	*/
 	async createSignedUploadUrl(path, options) {
 		var _this4 = this;
-		try {
+		return _this4.handleOperation(async () => {
 			let _path = _this4._getFinalPath(path);
 			const headers = _objectSpread2({}, _this4.headers);
 			if (options === null || options === void 0 ? void 0 : options.upsert) headers["x-upsert"] = "true";
-			const data = await post$1(_this4.fetch, `${_this4.url}/object/upload/sign/${_path}`, {}, { headers });
+			const data = await post(_this4.fetch, `${_this4.url}/object/upload/sign/${_path}`, {}, { headers });
 			const url = new URL(_this4.url + data.url);
 			const token = url.searchParams.get("token");
 			if (!token) throw new StorageError("No token returned by API");
 			return {
-				data: {
-					signedUrl: url.toString(),
-					path,
-					token
-				},
-				error: null
+				signedUrl: url.toString(),
+				path,
+				token
 			};
-		} catch (error) {
-			if (_this4.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		});
 	}
 	/**
 	* Replaces an existing file at the specified path with a new one.
@@ -612,24 +793,14 @@ var StorageFileApi = class {
 	*/
 	async move(fromPath, toPath, options) {
 		var _this6 = this;
-		try {
-			return {
-				data: await post$1(_this6.fetch, `${_this6.url}/object/move`, {
-					bucketId: _this6.bucketId,
-					sourceKey: fromPath,
-					destinationKey: toPath,
-					destinationBucket: options === null || options === void 0 ? void 0 : options.destinationBucket
-				}, { headers: _this6.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this6.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this6.handleOperation(async () => {
+			return await post(_this6.fetch, `${_this6.url}/object/move`, {
+				bucketId: _this6.bucketId,
+				sourceKey: fromPath,
+				destinationKey: toPath,
+				destinationBucket: options === null || options === void 0 ? void 0 : options.destinationBucket
+			}, { headers: _this6.headers });
+		});
 	}
 	/**
 	* Copies an existing file to a new path in the same bucket.
@@ -660,24 +831,14 @@ var StorageFileApi = class {
 	*/
 	async copy(fromPath, toPath, options) {
 		var _this7 = this;
-		try {
-			return {
-				data: { path: (await post$1(_this7.fetch, `${_this7.url}/object/copy`, {
-					bucketId: _this7.bucketId,
-					sourceKey: fromPath,
-					destinationKey: toPath,
-					destinationBucket: options === null || options === void 0 ? void 0 : options.destinationBucket
-				}, { headers: _this7.headers })).Key },
-				error: null
-			};
-		} catch (error) {
-			if (_this7.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this7.handleOperation(async () => {
+			return { path: (await post(_this7.fetch, `${_this7.url}/object/copy`, {
+				bucketId: _this7.bucketId,
+				sourceKey: fromPath,
+				destinationKey: toPath,
+				destinationBucket: options === null || options === void 0 ? void 0 : options.destinationBucket
+			}, { headers: _this7.headers })).Key };
+		});
 	}
 	/**
 	* Creates a signed URL. Use a signed URL to share a file for a fixed amount of time.
@@ -732,23 +893,12 @@ var StorageFileApi = class {
 	*/
 	async createSignedUrl(path, expiresIn, options) {
 		var _this8 = this;
-		try {
+		return _this8.handleOperation(async () => {
 			let _path = _this8._getFinalPath(path);
-			let data = await post$1(_this8.fetch, `${_this8.url}/object/sign/${_path}`, _objectSpread2({ expiresIn }, (options === null || options === void 0 ? void 0 : options.transform) ? { transform: options.transform } : {}), { headers: _this8.headers });
+			let data = await post(_this8.fetch, `${_this8.url}/object/sign/${_path}`, _objectSpread2({ expiresIn }, (options === null || options === void 0 ? void 0 : options.transform) ? { transform: options.transform } : {}), { headers: _this8.headers });
 			const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `&download=${options.download === true ? "" : options.download}` : "";
-			data = { signedUrl: encodeURI(`${_this8.url}${data.signedURL}${downloadQueryParam}`) };
-			return {
-				data,
-				error: null
-			};
-		} catch (error) {
-			if (_this8.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+			return { signedUrl: encodeURI(`${_this8.url}${data.signedURL}${downloadQueryParam}`) };
+		});
 	}
 	/**
 	* Creates multiple signed URLs. Use a signed URL to share a file for a fixed amount of time.
@@ -790,24 +940,14 @@ var StorageFileApi = class {
 	*/
 	async createSignedUrls(paths, expiresIn, options) {
 		var _this9 = this;
-		try {
-			const data = await post$1(_this9.fetch, `${_this9.url}/object/sign/${_this9.bucketId}`, {
+		return _this9.handleOperation(async () => {
+			const data = await post(_this9.fetch, `${_this9.url}/object/sign/${_this9.bucketId}`, {
 				expiresIn,
 				paths
 			}, { headers: _this9.headers });
 			const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `&download=${options.download === true ? "" : options.download}` : "";
-			return {
-				data: data.map((datum) => _objectSpread2(_objectSpread2({}, datum), {}, { signedUrl: datum.signedURL ? encodeURI(`${_this9.url}${datum.signedURL}${downloadQueryParam}`) : null })),
-				error: null
-			};
-		} catch (error) {
-			if (_this9.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+			return data.map((datum) => _objectSpread2(_objectSpread2({}, datum), {}, { signedUrl: datum.signedURL ? encodeURI(`${_this9.url}${datum.signedURL}${downloadQueryParam}`) : null }));
+		});
 	}
 	/**
 	* Downloads a file from a private bucket. For public buckets, make a request to the URL returned from `getPublicUrl` instead.
@@ -876,19 +1016,9 @@ var StorageFileApi = class {
 	async info(path) {
 		var _this10 = this;
 		const _path = _this10._getFinalPath(path);
-		try {
-			return {
-				data: recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers })),
-				error: null
-			};
-		} catch (error) {
-			if (_this10.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this10.handleOperation(async () => {
+			return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
+		});
 	}
 	/**
 	* Checks the existence of a file.
@@ -1013,19 +1143,9 @@ var StorageFileApi = class {
 	*/
 	async remove(paths) {
 		var _this12 = this;
-		try {
-			return {
-				data: await remove(_this12.fetch, `${_this12.url}/object/${_this12.bucketId}`, { prefixes: paths }, { headers: _this12.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this12.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this12.handleOperation(async () => {
+			return await remove(_this12.fetch, `${_this12.url}/object/${_this12.bucketId}`, { prefixes: paths }, { headers: _this12.headers });
+		});
 	}
 	/**
 	* Get file metadata
@@ -1097,20 +1217,10 @@ var StorageFileApi = class {
 	*/
 	async list(path, options, parameters) {
 		var _this13 = this;
-		try {
+		return _this13.handleOperation(async () => {
 			const body = _objectSpread2(_objectSpread2(_objectSpread2({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path || "" });
-			return {
-				data: await post$1(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters),
-				error: null
-			};
-		} catch (error) {
-			if (_this13.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+			return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
+		});
 	}
 	/**
 	* @experimental this method signature might change in the future
@@ -1121,20 +1231,10 @@ var StorageFileApi = class {
 	*/
 	async listV2(options, parameters) {
 		var _this14 = this;
-		try {
+		return _this14.handleOperation(async () => {
 			const body = _objectSpread2({}, options);
-			return {
-				data: await post$1(_this14.fetch, `${_this14.url}/object/list-v2/${_this14.bucketId}`, body, { headers: _this14.headers }, parameters),
-				error: null
-			};
-		} catch (error) {
-			if (_this14.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+			return await post(_this14.fetch, `${_this14.url}/object/list-v2/${_this14.bucketId}`, body, { headers: _this14.headers }, parameters);
+		});
 	}
 	encodeMetadata(metadata) {
 		return JSON.stringify(metadata);
@@ -1162,33 +1262,23 @@ var StorageFileApi = class {
 
 //#endregion
 //#region src/lib/version.ts
-const version = "2.91.1";
+const version = "2.91.2";
 
 //#endregion
 //#region src/lib/constants.ts
-const DEFAULT_HEADERS$1 = { "X-Client-Info": `storage-js/${version}` };
+const DEFAULT_HEADERS = { "X-Client-Info": `storage-js/${version}` };
 
 //#endregion
 //#region src/packages/StorageBucketApi.ts
-var StorageBucketApi = class {
+var StorageBucketApi = class extends BaseApiClient {
 	constructor(url, headers = {}, fetch$1, opts) {
-		this.shouldThrowOnError = false;
 		const baseUrl = new URL(url);
 		if (opts === null || opts === void 0 ? void 0 : opts.useNewHostname) {
 			if (/supabase\.(co|in|red)$/.test(baseUrl.hostname) && !baseUrl.hostname.includes("storage.supabase.")) baseUrl.hostname = baseUrl.hostname.replace("supabase.", "storage.supabase.");
 		}
-		this.url = baseUrl.href.replace(/\/$/, "");
-		this.headers = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS$1), headers);
-		this.fetch = resolveFetch$1(fetch$1);
-	}
-	/**
-	* Enable throwing errors instead of returning them.
-	*
-	* @category File Buckets
-	*/
-	throwOnError() {
-		this.shouldThrowOnError = true;
-		return this;
+		const finalUrl = baseUrl.href.replace(/\/$/, "");
+		const finalHeaders = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), headers);
+		super(finalUrl, finalHeaders, fetch$1, "storage");
 	}
 	/**
 	* Retrieves the details of all Storage buckets within an existing project.
@@ -1224,20 +1314,10 @@ var StorageBucketApi = class {
 	*/
 	async listBuckets(options) {
 		var _this = this;
-		try {
+		return _this.handleOperation(async () => {
 			const queryString = _this.listBucketOptionsToQueryString(options);
-			return {
-				data: await get(_this.fetch, `${_this.url}/bucket${queryString}`, { headers: _this.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+			return await get(_this.fetch, `${_this.url}/bucket${queryString}`, { headers: _this.headers });
+		});
 	}
 	/**
 	* Retrieves the details of an existing Storage bucket.
@@ -1274,19 +1354,9 @@ var StorageBucketApi = class {
 	*/
 	async getBucket(id) {
 		var _this2 = this;
-		try {
-			return {
-				data: await get(_this2.fetch, `${_this2.url}/bucket/${id}`, { headers: _this2.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this2.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this2.handleOperation(async () => {
+			return await get(_this2.fetch, `${_this2.url}/bucket/${id}`, { headers: _this2.headers });
+		});
 	}
 	/**
 	* Creates a new Storage bucket
@@ -1327,26 +1397,16 @@ var StorageBucketApi = class {
 	*/
 	async createBucket(id, options = { public: false }) {
 		var _this3 = this;
-		try {
-			return {
-				data: await post$1(_this3.fetch, `${_this3.url}/bucket`, {
-					id,
-					name: id,
-					type: options.type,
-					public: options.public,
-					file_size_limit: options.fileSizeLimit,
-					allowed_mime_types: options.allowedMimeTypes
-				}, { headers: _this3.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this3.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this3.handleOperation(async () => {
+			return await post(_this3.fetch, `${_this3.url}/bucket`, {
+				id,
+				name: id,
+				type: options.type,
+				public: options.public,
+				file_size_limit: options.fileSizeLimit,
+				allowed_mime_types: options.allowedMimeTypes
+			}, { headers: _this3.headers });
+		});
 	}
 	/**
 	* Updates a Storage bucket
@@ -1385,25 +1445,15 @@ var StorageBucketApi = class {
 	*/
 	async updateBucket(id, options) {
 		var _this4 = this;
-		try {
-			return {
-				data: await put(_this4.fetch, `${_this4.url}/bucket/${id}`, {
-					id,
-					name: id,
-					public: options.public,
-					file_size_limit: options.fileSizeLimit,
-					allowed_mime_types: options.allowedMimeTypes
-				}, { headers: _this4.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this4.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this4.handleOperation(async () => {
+			return await put(_this4.fetch, `${_this4.url}/bucket/${id}`, {
+				id,
+				name: id,
+				public: options.public,
+				file_size_limit: options.fileSizeLimit,
+				allowed_mime_types: options.allowedMimeTypes
+			}, { headers: _this4.headers });
+		});
 	}
 	/**
 	* Removes all objects inside a single bucket.
@@ -1431,19 +1481,9 @@ var StorageBucketApi = class {
 	*/
 	async emptyBucket(id) {
 		var _this5 = this;
-		try {
-			return {
-				data: await post$1(_this5.fetch, `${_this5.url}/bucket/${id}/empty`, {}, { headers: _this5.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this5.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this5.handleOperation(async () => {
+			return await post(_this5.fetch, `${_this5.url}/bucket/${id}/empty`, {}, { headers: _this5.headers });
+		});
 	}
 	/**
 	* Deletes an existing bucket. A bucket can't be deleted with existing objects inside it.
@@ -1472,19 +1512,9 @@ var StorageBucketApi = class {
 	*/
 	async deleteBucket(id) {
 		var _this6 = this;
-		try {
-			return {
-				data: await remove(_this6.fetch, `${_this6.url}/bucket/${id}`, {}, { headers: _this6.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this6.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this6.handleOperation(async () => {
+			return await remove(_this6.fetch, `${_this6.url}/bucket/${id}`, {}, { headers: _this6.headers });
+		});
 	}
 	listBucketOptionsToQueryString(options) {
 		const params = {};
@@ -1505,7 +1535,7 @@ var StorageBucketApi = class {
 * Client class for managing Analytics Buckets using Iceberg tables
 * Provides methods for creating, listing, and deleting analytics buckets
 */
-var StorageAnalyticsClient = class {
+var StorageAnalyticsClient = class extends BaseApiClient {
 	/**
 	* @alpha
 	*
@@ -1524,25 +1554,9 @@ var StorageAnalyticsClient = class {
 	* ```
 	*/
 	constructor(url, headers = {}, fetch$1) {
-		this.shouldThrowOnError = false;
-		this.url = url.replace(/\/$/, "");
-		this.headers = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS$1), headers);
-		this.fetch = resolveFetch$1(fetch$1);
-	}
-	/**
-	* @alpha
-	*
-	* Enable throwing errors instead of returning them in the response
-	* When enabled, failed operations will throw instead of returning { data: null, error }
-	*
-	* **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-	*
-	* @category Analytics Buckets
-	* @returns This instance for method chaining
-	*/
-	throwOnError() {
-		this.shouldThrowOnError = true;
-		return this;
+		const finalUrl = url.replace(/\/$/, "");
+		const finalHeaders = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), headers);
+		super(finalUrl, finalHeaders, fetch$1, "storage");
 	}
 	/**
 	* @alpha
@@ -1580,19 +1594,9 @@ var StorageAnalyticsClient = class {
 	*/
 	async createBucket(name) {
 		var _this = this;
-		try {
-			return {
-				data: await post$1(_this.fetch, `${_this.url}/bucket`, { name }, { headers: _this.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this.handleOperation(async () => {
+			return await post(_this.fetch, `${_this.url}/bucket`, { name }, { headers: _this.headers });
+		});
 	}
 	/**
 	* @alpha
@@ -1642,7 +1646,7 @@ var StorageAnalyticsClient = class {
 	*/
 	async listBuckets(options) {
 		var _this2 = this;
-		try {
+		return _this2.handleOperation(async () => {
 			const queryParams = new URLSearchParams();
 			if ((options === null || options === void 0 ? void 0 : options.limit) !== void 0) queryParams.set("limit", options.limit.toString());
 			if ((options === null || options === void 0 ? void 0 : options.offset) !== void 0) queryParams.set("offset", options.offset.toString());
@@ -1651,18 +1655,8 @@ var StorageAnalyticsClient = class {
 			if (options === null || options === void 0 ? void 0 : options.search) queryParams.set("search", options.search);
 			const queryString = queryParams.toString();
 			const url = queryString ? `${_this2.url}/bucket?${queryString}` : `${_this2.url}/bucket`;
-			return {
-				data: await get(_this2.fetch, url, { headers: _this2.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this2.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+			return await get(_this2.fetch, url, { headers: _this2.headers });
+		});
 	}
 	/**
 	* @alpha
@@ -1697,19 +1691,9 @@ var StorageAnalyticsClient = class {
 	*/
 	async deleteBucket(bucketName) {
 		var _this3 = this;
-		try {
-			return {
-				data: await remove(_this3.fetch, `${_this3.url}/bucket/${bucketName}`, {}, { headers: _this3.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this3.shouldThrowOnError) throw error;
-			if (isStorageError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this3.handleOperation(async () => {
+			return await remove(_this3.fetch, `${_this3.url}/bucket/${bucketName}`, {}, { headers: _this3.headers });
+		});
 	}
 	/**
 	* @alpha
@@ -1869,528 +1853,160 @@ var StorageAnalyticsClient = class {
 };
 
 //#endregion
-//#region src/lib/vectors/constants.ts
-const DEFAULT_HEADERS = {
-	"X-Client-Info": `storage-js/${version}`,
-	"Content-Type": "application/json"
-};
-
-//#endregion
-//#region src/lib/vectors/errors.ts
+//#region src/packages/VectorIndexApi.ts
 /**
-* Base error class for all Storage Vectors errors
+* @hidden
+* Base implementation for vector index operations.
+* Use {@link VectorBucketScope} via `supabase.storage.vectors.from('bucket')` instead.
 */
-var StorageVectorsError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.__isStorageVectorsError = true;
-		this.name = "StorageVectorsError";
+var VectorIndexApi = class extends BaseApiClient {
+	/** Creates a new VectorIndexApi instance */
+	constructor(url, headers = {}, fetch$1) {
+		const finalUrl = url.replace(/\/$/, "");
+		const finalHeaders = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), {}, { "Content-Type": "application/json" }, headers);
+		super(finalUrl, finalHeaders, fetch$1, "vectors");
+	}
+	/** Creates a new vector index within a bucket */
+	async createIndex(options) {
+		var _this = this;
+		return _this.handleOperation(async () => {
+			return await post(_this.fetch, `${_this.url}/CreateIndex`, options, { headers: _this.headers }) || {};
+		});
+	}
+	/** Retrieves metadata for a specific vector index */
+	async getIndex(vectorBucketName, indexName) {
+		var _this2 = this;
+		return _this2.handleOperation(async () => {
+			return await post(_this2.fetch, `${_this2.url}/GetIndex`, {
+				vectorBucketName,
+				indexName
+			}, { headers: _this2.headers });
+		});
+	}
+	/** Lists vector indexes within a bucket with optional filtering and pagination */
+	async listIndexes(options) {
+		var _this3 = this;
+		return _this3.handleOperation(async () => {
+			return await post(_this3.fetch, `${_this3.url}/ListIndexes`, options, { headers: _this3.headers });
+		});
+	}
+	/** Deletes a vector index and all its data */
+	async deleteIndex(vectorBucketName, indexName) {
+		var _this4 = this;
+		return _this4.handleOperation(async () => {
+			return await post(_this4.fetch, `${_this4.url}/DeleteIndex`, {
+				vectorBucketName,
+				indexName
+			}, { headers: _this4.headers }) || {};
+		});
 	}
 };
+
+//#endregion
+//#region src/packages/VectorDataApi.ts
 /**
-* Type guard to check if an error is a StorageVectorsError
-* @param error - The error to check
-* @returns True if the error is a StorageVectorsError
-*/
-function isStorageVectorsError(error) {
-	return typeof error === "object" && error !== null && "__isStorageVectorsError" in error;
-}
-/**
-* API error returned from S3 Vectors service
-* Includes HTTP status code and service-specific error code
+* @hidden
+* Base implementation for vector data operations.
+* Use {@link VectorIndexScope} via `supabase.storage.vectors.from('bucket').index('idx')` instead.
 */
-var StorageVectorsApiError = class extends StorageVectorsError {
-	constructor(message, status, statusCode) {
-		super(message);
-		this.name = "StorageVectorsApiError";
-		this.status = status;
-		this.statusCode = statusCode;
-	}
-	toJSON() {
-		return {
-			name: this.name,
-			message: this.message,
-			status: this.status,
-			statusCode: this.statusCode
-		};
-	}
-};
-/**
-* Unknown error that doesn't match expected error patterns
-* Wraps the original error for debugging
-*/
-var StorageVectorsUnknownError = class extends StorageVectorsError {
-	constructor(message, originalError) {
-		super(message);
-		this.name = "StorageVectorsUnknownError";
-		this.originalError = originalError;
-	}
-};
-/**
-* Error codes specific to S3 Vectors API
-* Maps AWS service errors to application-friendly error codes
-*/
-let StorageVectorsErrorCode = /* @__PURE__ */ function(StorageVectorsErrorCode$1) {
-	/** Internal server fault (HTTP 500) */
-	StorageVectorsErrorCode$1["InternalError"] = "InternalError";
-	/** Resource already exists / conflict (HTTP 409) */
-	StorageVectorsErrorCode$1["S3VectorConflictException"] = "S3VectorConflictException";
-	/** Resource not found (HTTP 404) */
-	StorageVectorsErrorCode$1["S3VectorNotFoundException"] = "S3VectorNotFoundException";
-	/** Delete bucket while not empty (HTTP 400) */
-	StorageVectorsErrorCode$1["S3VectorBucketNotEmpty"] = "S3VectorBucketNotEmpty";
-	/** Exceeds bucket quota/limit (HTTP 400) */
-	StorageVectorsErrorCode$1["S3VectorMaxBucketsExceeded"] = "S3VectorMaxBucketsExceeded";
-	/** Exceeds index quota/limit (HTTP 400) */
-	StorageVectorsErrorCode$1["S3VectorMaxIndexesExceeded"] = "S3VectorMaxIndexesExceeded";
-	return StorageVectorsErrorCode$1;
-}({});
-
-//#endregion
-//#region src/lib/vectors/helpers.ts
-/**
-* Resolves the fetch implementation to use
-* Uses custom fetch if provided, otherwise uses native fetch
-*
-* @param customFetch - Optional custom fetch implementation
-* @returns Resolved fetch function
-*/
-const resolveFetch = (customFetch) => {
-	if (customFetch) return (...args) => customFetch(...args);
-	return (...args) => fetch(...args);
-};
-/**
-* Resolves the Response constructor to use
-* Returns native Response constructor
-*
-* @returns Response constructor
-*/
-const resolveResponse = () => {
-	return Response;
-};
-/**
-* Determine if input is a plain object
-* An object is plain if it's created by either {}, new Object(), or Object.create(null)
-*
-* @param value - Value to check
-* @returns True if value is a plain object
-* @source https://github.com/sindresorhus/is-plain-obj
-*/
-const isPlainObject = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-};
-/**
-* Normalizes a number array to float32 format
-* Ensures all vector values are valid 32-bit floats
-*
-* @param values - Array of numbers to normalize
-* @returns Normalized float32 array
-*/
-const normalizeToFloat32 = (values) => {
-	return Array.from(new Float32Array(values));
-};
-/**
-* Validates vector dimensions match expected dimension
-* Throws error if dimensions don't match
-*
-* @param vector - Vector data to validate
-* @param expectedDimension - Expected vector dimension
-* @throws Error if dimensions don't match
-*/
-const validateVectorDimension = (vector, expectedDimension) => {
-	if (expectedDimension !== void 0 && vector.float32.length !== expectedDimension) throw new Error(`Vector dimension mismatch: expected ${expectedDimension}, got ${vector.float32.length}`);
-};
-
-//#endregion
-//#region src/lib/vectors/fetch.ts
-/**
-* Extracts error message from various error response formats
-* @param err - Error object from API
-* @returns Human-readable error message
-*/
-const _getErrorMessage = (err) => err.msg || err.message || err.error_description || err.error || JSON.stringify(err);
-/**
-* Handles fetch errors and converts them to StorageVectors error types
-* @param error - The error caught from fetch
-* @param reject - Promise rejection function
-* @param options - Fetch options that may affect error handling
-*/
-const handleError = async (error, reject, options) => {
-	if (error && typeof error === "object" && "status" in error && "ok" in error && typeof error.status === "number" && !(options === null || options === void 0 ? void 0 : options.noResolveJson)) {
-		const status = error.status || 500;
-		const responseError = error;
-		if (typeof responseError.json === "function") responseError.json().then((err) => {
-			const statusCode = (err === null || err === void 0 ? void 0 : err.statusCode) || (err === null || err === void 0 ? void 0 : err.code) || status + "";
-			reject(new StorageVectorsApiError(_getErrorMessage(err), status, statusCode));
-		}).catch(() => {
-			const statusCode = status + "";
-			reject(new StorageVectorsApiError(responseError.statusText || `HTTP ${status} error`, status, statusCode));
-		});
-		else {
-			const statusCode = status + "";
-			reject(new StorageVectorsApiError(responseError.statusText || `HTTP ${status} error`, status, statusCode));
-		}
-	} else reject(new StorageVectorsUnknownError(_getErrorMessage(error), error));
-};
-/**
-* Builds request parameters for fetch calls
-* @param method - HTTP method
-* @param options - Custom fetch options
-* @param parameters - Additional fetch parameters like AbortSignal
-* @param body - Request body (will be JSON stringified if plain object)
-* @returns Complete fetch request parameters
-*/
-const _getRequestParams = (method, options, parameters, body) => {
-	const params = {
-		method,
-		headers: (options === null || options === void 0 ? void 0 : options.headers) || {}
-	};
-	if (method === "GET" || !body) return params;
-	if (isPlainObject(body)) {
-		params.headers = _objectSpread2({ "Content-Type": "application/json" }, options === null || options === void 0 ? void 0 : options.headers);
-		params.body = JSON.stringify(body);
-	} else params.body = body;
-	return _objectSpread2(_objectSpread2({}, params), parameters);
-};
-/**
-* Internal request handler that wraps fetch with error handling
-* @param fetcher - Fetch function to use
-* @param method - HTTP method
-* @param url - Request URL
-* @param options - Custom fetch options
-* @param parameters - Additional fetch parameters
-* @param body - Request body
-* @returns Promise with parsed response or error
-*/
-async function _handleRequest(fetcher, method, url, options, parameters, body) {
-	return new Promise((resolve, reject) => {
-		fetcher(url, _getRequestParams(method, options, parameters, body)).then((result) => {
-			if (!result.ok) throw result;
-			if (options === null || options === void 0 ? void 0 : options.noResolveJson) return result;
-			const contentType = result.headers.get("content-type");
-			if (!contentType || !contentType.includes("application/json")) return {};
-			return result.json();
-		}).then((data) => resolve(data)).catch((error) => handleError(error, reject, options));
-	});
-}
-/**
-* Performs a POST request
-* @param fetcher - Fetch function to use
-* @param url - Request URL
-* @param body - Request body to be JSON stringified
-* @param options - Custom fetch options
-* @param parameters - Additional fetch parameters
-* @returns Promise with parsed response
-*/
-async function post(fetcher, url, body, options, parameters) {
-	return _handleRequest(fetcher, "POST", url, options, parameters, body);
-}
-
-//#endregion
-//#region src/lib/vectors/VectorIndexApi.ts
-/**
-* @hidden
-* Base implementation for vector index operations.
-* Use {@link VectorBucketScope} via `supabase.storage.vectors.from('bucket')` instead.
-*/
-var VectorIndexApi = class {
-	/** Creates a new VectorIndexApi instance */
-	constructor(url, headers = {}, fetch$1) {
-		this.shouldThrowOnError = false;
-		this.url = url.replace(/\/$/, "");
-		this.headers = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), headers);
-		this.fetch = resolveFetch(fetch$1);
-	}
-	/** Enable throwing errors instead of returning them in the response */
-	throwOnError() {
-		this.shouldThrowOnError = true;
-		return this;
-	}
-	/** Creates a new vector index within a bucket */
-	async createIndex(options) {
-		var _this = this;
-		try {
-			return {
-				data: await post(_this.fetch, `${_this.url}/CreateIndex`, options, { headers: _this.headers }) || {},
-				error: null
-			};
-		} catch (error) {
-			if (_this.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
-	}
-	/** Retrieves metadata for a specific vector index */
-	async getIndex(vectorBucketName, indexName) {
-		var _this2 = this;
-		try {
-			return {
-				data: await post(_this2.fetch, `${_this2.url}/GetIndex`, {
-					vectorBucketName,
-					indexName
-				}, { headers: _this2.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this2.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
-	}
-	/** Lists vector indexes within a bucket with optional filtering and pagination */
-	async listIndexes(options) {
-		var _this3 = this;
-		try {
-			return {
-				data: await post(_this3.fetch, `${_this3.url}/ListIndexes`, options, { headers: _this3.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this3.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
-	}
-	/** Deletes a vector index and all its data */
-	async deleteIndex(vectorBucketName, indexName) {
-		var _this4 = this;
-		try {
-			return {
-				data: await post(_this4.fetch, `${_this4.url}/DeleteIndex`, {
-					vectorBucketName,
-					indexName
-				}, { headers: _this4.headers }) || {},
-				error: null
-			};
-		} catch (error) {
-			if (_this4.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
-	}
-};
-
-//#endregion
-//#region src/lib/vectors/VectorDataApi.ts
-/**
-* @hidden
-* Base implementation for vector data operations.
-* Use {@link VectorIndexScope} via `supabase.storage.vectors.from('bucket').index('idx')` instead.
-*/
-var VectorDataApi = class {
-	/** Creates a new VectorDataApi instance */
-	constructor(url, headers = {}, fetch$1) {
-		this.shouldThrowOnError = false;
-		this.url = url.replace(/\/$/, "");
-		this.headers = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), headers);
-		this.fetch = resolveFetch(fetch$1);
-	}
-	/** Enable throwing errors instead of returning them in the response */
-	throwOnError() {
-		this.shouldThrowOnError = true;
-		return this;
+var VectorDataApi = class extends BaseApiClient {
+	/** Creates a new VectorDataApi instance */
+	constructor(url, headers = {}, fetch$1) {
+		const finalUrl = url.replace(/\/$/, "");
+		const finalHeaders = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), {}, { "Content-Type": "application/json" }, headers);
+		super(finalUrl, finalHeaders, fetch$1, "vectors");
 	}
 	/** Inserts or updates vectors in batch (1-500 per request) */
 	async putVectors(options) {
 		var _this = this;
-		try {
-			if (options.vectors.length < 1 || options.vectors.length > 500) throw new Error("Vector batch size must be between 1 and 500 items");
-			return {
-				data: await post(_this.fetch, `${_this.url}/PutVectors`, options, { headers: _this.headers }) || {},
-				error: null
-			};
-		} catch (error) {
-			if (_this.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		if (options.vectors.length < 1 || options.vectors.length > 500) throw new Error("Vector batch size must be between 1 and 500 items");
+		return _this.handleOperation(async () => {
+			return await post(_this.fetch, `${_this.url}/PutVectors`, options, { headers: _this.headers }) || {};
+		});
 	}
 	/** Retrieves vectors by their keys in batch */
 	async getVectors(options) {
 		var _this2 = this;
-		try {
-			return {
-				data: await post(_this2.fetch, `${_this2.url}/GetVectors`, options, { headers: _this2.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this2.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this2.handleOperation(async () => {
+			return await post(_this2.fetch, `${_this2.url}/GetVectors`, options, { headers: _this2.headers });
+		});
 	}
 	/** Lists vectors in an index with pagination */
 	async listVectors(options) {
 		var _this3 = this;
-		try {
-			if (options.segmentCount !== void 0) {
-				if (options.segmentCount < 1 || options.segmentCount > 16) throw new Error("segmentCount must be between 1 and 16");
-				if (options.segmentIndex !== void 0) {
-					if (options.segmentIndex < 0 || options.segmentIndex >= options.segmentCount) throw new Error(`segmentIndex must be between 0 and ${options.segmentCount - 1}`);
-				}
+		if (options.segmentCount !== void 0) {
+			if (options.segmentCount < 1 || options.segmentCount > 16) throw new Error("segmentCount must be between 1 and 16");
+			if (options.segmentIndex !== void 0) {
+				if (options.segmentIndex < 0 || options.segmentIndex >= options.segmentCount) throw new Error(`segmentIndex must be between 0 and ${options.segmentCount - 1}`);
 			}
-			return {
-				data: await post(_this3.fetch, `${_this3.url}/ListVectors`, options, { headers: _this3.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this3.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
 		}
+		return _this3.handleOperation(async () => {
+			return await post(_this3.fetch, `${_this3.url}/ListVectors`, options, { headers: _this3.headers });
+		});
 	}
 	/** Queries for similar vectors using approximate nearest neighbor search */
 	async queryVectors(options) {
 		var _this4 = this;
-		try {
-			return {
-				data: await post(_this4.fetch, `${_this4.url}/QueryVectors`, options, { headers: _this4.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this4.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this4.handleOperation(async () => {
+			return await post(_this4.fetch, `${_this4.url}/QueryVectors`, options, { headers: _this4.headers });
+		});
 	}
 	/** Deletes vectors by their keys in batch (1-500 per request) */
 	async deleteVectors(options) {
 		var _this5 = this;
-		try {
-			if (options.keys.length < 1 || options.keys.length > 500) throw new Error("Keys batch size must be between 1 and 500 items");
-			return {
-				data: await post(_this5.fetch, `${_this5.url}/DeleteVectors`, options, { headers: _this5.headers }) || {},
-				error: null
-			};
-		} catch (error) {
-			if (_this5.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		if (options.keys.length < 1 || options.keys.length > 500) throw new Error("Keys batch size must be between 1 and 500 items");
+		return _this5.handleOperation(async () => {
+			return await post(_this5.fetch, `${_this5.url}/DeleteVectors`, options, { headers: _this5.headers }) || {};
+		});
 	}
 };
 
 //#endregion
-//#region src/lib/vectors/VectorBucketApi.ts
+//#region src/packages/VectorBucketApi.ts
 /**
 * @hidden
 * Base implementation for vector bucket operations.
 * Use {@link StorageVectorsClient} via `supabase.storage.vectors` instead.
 */
-var VectorBucketApi = class {
+var VectorBucketApi = class extends BaseApiClient {
 	/** Creates a new VectorBucketApi instance */
 	constructor(url, headers = {}, fetch$1) {
-		this.shouldThrowOnError = false;
-		this.url = url.replace(/\/$/, "");
-		this.headers = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), headers);
-		this.fetch = resolveFetch(fetch$1);
-	}
-	/** Enable throwing errors instead of returning them in the response */
-	throwOnError() {
-		this.shouldThrowOnError = true;
-		return this;
+		const finalUrl = url.replace(/\/$/, "");
+		const finalHeaders = _objectSpread2(_objectSpread2({}, DEFAULT_HEADERS), {}, { "Content-Type": "application/json" }, headers);
+		super(finalUrl, finalHeaders, fetch$1, "vectors");
 	}
 	/** Creates a new vector bucket */
 	async createBucket(vectorBucketName) {
 		var _this = this;
-		try {
-			return {
-				data: await post(_this.fetch, `${_this.url}/CreateVectorBucket`, { vectorBucketName }, { headers: _this.headers }) || {},
-				error: null
-			};
-		} catch (error) {
-			if (_this.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this.handleOperation(async () => {
+			return await post(_this.fetch, `${_this.url}/CreateVectorBucket`, { vectorBucketName }, { headers: _this.headers }) || {};
+		});
 	}
 	/** Retrieves metadata for a specific vector bucket */
 	async getBucket(vectorBucketName) {
 		var _this2 = this;
-		try {
-			return {
-				data: await post(_this2.fetch, `${_this2.url}/GetVectorBucket`, { vectorBucketName }, { headers: _this2.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this2.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this2.handleOperation(async () => {
+			return await post(_this2.fetch, `${_this2.url}/GetVectorBucket`, { vectorBucketName }, { headers: _this2.headers });
+		});
 	}
 	/** Lists vector buckets with optional filtering and pagination */
 	async listBuckets(options = {}) {
 		var _this3 = this;
-		try {
-			return {
-				data: await post(_this3.fetch, `${_this3.url}/ListVectorBuckets`, options, { headers: _this3.headers }),
-				error: null
-			};
-		} catch (error) {
-			if (_this3.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this3.handleOperation(async () => {
+			return await post(_this3.fetch, `${_this3.url}/ListVectorBuckets`, options, { headers: _this3.headers });
+		});
 	}
 	/** Deletes a vector bucket (must be empty first) */
 	async deleteBucket(vectorBucketName) {
 		var _this4 = this;
-		try {
-			return {
-				data: await post(_this4.fetch, `${_this4.url}/DeleteVectorBucket`, { vectorBucketName }, { headers: _this4.headers }) || {},
-				error: null
-			};
-		} catch (error) {
-			if (_this4.shouldThrowOnError) throw error;
-			if (isStorageVectorsError(error)) return {
-				data: null,
-				error
-			};
-			throw error;
-		}
+		return _this4.handleOperation(async () => {
+			return await post(_this4.fetch, `${_this4.url}/DeleteVectorBucket`, { vectorBucketName }, { headers: _this4.headers }) || {};
+		});
 	}
 };
 
 //#endregion
-//#region src/lib/vectors/StorageVectorsClient.ts
+//#region src/packages/StorageVectorsClient.ts
 /**
 *
 * @alpha
@@ -3009,11 +2625,6 @@ exports.VectorBucketScope = VectorBucketScope;
 exports.VectorDataApi = VectorDataApi;
 exports.VectorIndexApi = VectorIndexApi;
 exports.VectorIndexScope = VectorIndexScope;
-exports.isPlainObject = isPlainObject;
 exports.isStorageError = isStorageError;
 exports.isStorageVectorsError = isStorageVectorsError;
-exports.normalizeToFloat32 = normalizeToFloat32;
-exports.resolveFetch = resolveFetch;
-exports.resolveResponse = resolveResponse;
-exports.validateVectorDimension = validateVectorDimension;
 //# sourceMappingURL=index.cjs.map