@finueva/drive 0.1.0

package/dist/client.js

@@ -0,0 +1,1337 @@
+//#region ../../node_modules/.pnpm/openapi-fetch@0.17.0/node_modules/openapi-fetch/dist/index.mjs
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const supportsRequestInitExt = () => {
+	return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+	return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, pathSerializer: globalPathSerializer, headers: baseHeaders, requestInitExt = void 0, ...baseOptions } = { ...clientOptions };
+	requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+	baseUrl = removeTrailingSlash(baseUrl);
+	const globalMiddlewares = [];
+	async function coreFetch(schemaPath, fetchOptions) {
+		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, pathSerializer: requestPathSerializer, body, middleware: requestMiddlewares = [], ...init } = fetchOptions || {};
+		let finalBaseUrl = baseUrl;
+		if (localBaseUrl) finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+		let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+		if (requestQuerySerializer) querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+			...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+			...requestQuerySerializer
+		});
+		const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+		const serializedBody = body === void 0 ? void 0 : bodySerializer(body, mergeHeaders(baseHeaders, headers, params.header));
+		const finalHeaders = mergeHeaders(serializedBody === void 0 || serializedBody instanceof FormData ? {} : { "Content-Type": "application/json" }, baseHeaders, headers, params.header);
+		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+		const requestInit = {
+			redirect: "follow",
+			...baseOptions,
+			...init,
+			body: serializedBody,
+			headers: finalHeaders
+		};
+		let id;
+		let options;
+		let request = new Request(createFinalURL(schemaPath, {
+			baseUrl: finalBaseUrl,
+			params,
+			querySerializer,
+			pathSerializer
+		}), requestInit);
+		let response;
+		for (const key in init) if (!(key in request)) request[key] = init[key];
+		if (finalMiddlewares.length) {
+			id = randomID();
+			options = Object.freeze({
+				baseUrl: finalBaseUrl,
+				fetch,
+				parseAs,
+				querySerializer,
+				bodySerializer,
+				pathSerializer
+			});
+			for (const m of finalMiddlewares) if (m && typeof m === "object" && typeof m.onRequest === "function") {
+				const result = await m.onRequest({
+					request,
+					schemaPath,
+					params,
+					options,
+					id
+				});
+				if (result) if (result instanceof Request) request = result;
+				else if (result instanceof Response) {
+					response = result;
+					break;
+				} else throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+			}
+		}
+		if (!response) {
+			try {
+				response = await fetch(request, requestInitExt);
+			} catch (error2) {
+				let errorAfterMiddleware = error2;
+				if (finalMiddlewares.length) for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+					const m = finalMiddlewares[i];
+					if (m && typeof m === "object" && typeof m.onError === "function") {
+						const result = await m.onError({
+							request,
+							error: errorAfterMiddleware,
+							schemaPath,
+							params,
+							options,
+							id
+						});
+						if (result) {
+							if (result instanceof Response) {
+								errorAfterMiddleware = void 0;
+								response = result;
+								break;
+							}
+							if (result instanceof Error) {
+								errorAfterMiddleware = result;
+								continue;
+							}
+							throw new Error("onError: must return new Response() or instance of Error");
+						}
+					}
+				}
+				if (errorAfterMiddleware) throw errorAfterMiddleware;
+			}
+			if (finalMiddlewares.length) for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+				const m = finalMiddlewares[i];
+				if (m && typeof m === "object" && typeof m.onResponse === "function") {
+					const result = await m.onResponse({
+						request,
+						response,
+						schemaPath,
+						params,
+						options,
+						id
+					});
+					if (result) {
+						if (!(result instanceof Response)) throw new Error("onResponse: must return new Response() when modifying the response");
+						response = result;
+					}
+				}
+			}
+		}
+		const contentLength = response.headers.get("Content-Length");
+		if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) return response.ok ? {
+			data: void 0,
+			response
+		} : {
+			error: void 0,
+			response
+		};
+		if (response.ok) {
+			const getResponseData = async () => {
+				if (parseAs === "stream") return response.body;
+				if (parseAs === "json" && !contentLength) {
+					const raw = await response.text();
+					return raw ? JSON.parse(raw) : void 0;
+				}
+				return await response[parseAs]();
+			};
+			return {
+				data: await getResponseData(),
+				response
+			};
+		}
+		let error = await response.text();
+		try {
+			error = JSON.parse(error);
+		} catch {}
+		return {
+			error,
+			response
+		};
+	}
+	return {
+		request(method, url, init) {
+			return coreFetch(url, {
+				...init,
+				method: method.toUpperCase()
+			});
+		},
+		GET(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "GET"
+			});
+		},
+		PUT(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "PUT"
+			});
+		},
+		POST(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "POST"
+			});
+		},
+		DELETE(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "DELETE"
+			});
+		},
+		OPTIONS(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "OPTIONS"
+			});
+		},
+		HEAD(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "HEAD"
+			});
+		},
+		PATCH(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "PATCH"
+			});
+		},
+		TRACE(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "TRACE"
+			});
+		},
+		use(...middleware) {
+			for (const m of middleware) {
+				if (!m) continue;
+				if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+				globalMiddlewares.push(m);
+			}
+		},
+		eject(...middleware) {
+			for (const m of middleware) {
+				const i = globalMiddlewares.indexOf(m);
+				if (i !== -1) globalMiddlewares.splice(i, 1);
+			}
+		}
+	};
+}
+function serializePrimitiveParam(name, value, options) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+	if (!value || typeof value !== "object") return "";
+	const values = [];
+	const joiner = {
+		simple: ",",
+		label: ".",
+		matrix: ";"
+	}[options.style] || "&";
+	if (options.style !== "deepObject" && options.explode === false) {
+		for (const k in value) values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+		const final2 = values.join(",");
+		switch (options.style) {
+			case "form": return `${name}=${final2}`;
+			case "label": return `.${final2}`;
+			case "matrix": return `;${name}=${final2}`;
+			default: return final2;
+		}
+	}
+	for (const k in value) {
+		const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+		values.push(serializePrimitiveParam(finalName, value[k], options));
+	}
+	const final = values.join(joiner);
+	return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+	if (!Array.isArray(value)) return "";
+	if (options.explode === false) {
+		const joiner2 = {
+			form: ",",
+			spaceDelimited: "%20",
+			pipeDelimited: "|"
+		}[options.style] || ",";
+		const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+		switch (options.style) {
+			case "simple": return final;
+			case "label": return `.${final}`;
+			case "matrix": return `;${name}=${final}`;
+			default: return `${name}=${final}`;
+		}
+	}
+	const joiner = {
+		simple: ",",
+		label: ".",
+		matrix: ";"
+	}[options.style] || "&";
+	const values = [];
+	for (const v of value) if (options.style === "simple" || options.style === "label") values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+	else values.push(serializePrimitiveParam(name, v, options));
+	return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+	return function querySerializer(queryParams) {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			if (Array.isArray(value)) {
+				if (value.length === 0) continue;
+				search.push(serializeArrayParam(name, value, {
+					style: "form",
+					explode: true,
+					...options?.array,
+					allowReserved: options?.allowReserved || false
+				}));
+				continue;
+			}
+			if (typeof value === "object") {
+				search.push(serializeObjectParam(name, value, {
+					style: "deepObject",
+					explode: true,
+					...options?.object,
+					allowReserved: options?.allowReserved || false
+				}));
+				continue;
+			}
+			search.push(serializePrimitiveParam(name, value, options));
+		}
+		return search.join("&");
+	};
+}
+function defaultPathSerializer(pathname, pathParams) {
+	let nextURL = pathname;
+	for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+		let name = match.substring(1, match.length - 1);
+		let explode = false;
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			style = "label";
+			name = name.substring(1);
+		} else if (name.startsWith(";")) {
+			style = "matrix";
+			name = name.substring(1);
+		}
+		if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) continue;
+		const value = pathParams[name];
+		if (Array.isArray(value)) {
+			nextURL = nextURL.replace(match, serializeArrayParam(name, value, {
+				style,
+				explode
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			nextURL = nextURL.replace(match, serializeObjectParam(name, value, {
+				style,
+				explode
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+			continue;
+		}
+		nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+	}
+	return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+	if (body instanceof FormData) return body;
+	if (headers) {
+		if ((headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"]) === "application/x-www-form-urlencoded") return new URLSearchParams(body).toString();
+	}
+	return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+	let finalURL = `${options.baseUrl}${pathname}`;
+	if (options.params?.path) finalURL = options.pathSerializer(finalURL, options.params.path);
+	let search = options.querySerializer(options.params.query ?? {});
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) finalURL += `?${search}`;
+	return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+	const finalHeaders = new Headers();
+	for (const h of allHeaders) {
+		if (!h || typeof h !== "object") continue;
+		const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+		for (const [k, v] of iterator) if (v === null) finalHeaders.delete(k);
+		else if (Array.isArray(v)) for (const v2 of v) finalHeaders.append(k, v2);
+		else if (v !== void 0) finalHeaders.set(k, v);
+	}
+	return finalHeaders;
+}
+function removeTrailingSlash(url) {
+	if (url.endsWith("/")) return url.substring(0, url.length - 1);
+	return url;
+}
+String.fromCharCode;
+const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s] = path.split("?");
+	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+//#endregion
+//#region src/core.ts
+const DRIVE_API_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"invalid_pagination_cursor",
+	"invalid_idempotency_key",
+	"precondition_failed",
+	"idempotency_conflict",
+	"quota_exceeded",
+	"service_unavailable",
+	"internal_error"
+]);
+const DRIVE_API_ERROR_MESSAGES = Object.freeze({
+	authentication_required: "Authentication is required.",
+	identity_authority_unavailable: "Authentication is temporarily unavailable.",
+	permission_denied: "The requested action is not permitted.",
+	resource_not_found: "The requested resource was not found.",
+	invalid_request: "The request is invalid.",
+	invalid_pagination_cursor: "The pagination cursor is invalid.",
+	invalid_idempotency_key: "The idempotency key is invalid.",
+	precondition_failed: "The request precondition failed.",
+	idempotency_conflict: "The idempotency key conflicts with an earlier request.",
+	quota_exceeded: "The workspace storage quota would be exceeded.",
+	service_unavailable: "The service is temporarily unavailable.",
+	internal_error: "The request could not be completed."
+});
+const SDK_MESSAGES = Object.freeze({
+	invalid_input: "The Drive SDK input is invalid.",
+	credential_unavailable: "A Drive credential could not be obtained.",
+	network_error: "The Drive request could not reach the service.",
+	timeout: "The Drive request timed out.",
+	aborted: "The Drive request was aborted.",
+	invalid_response: "Drive returned an invalid response."
+});
+var DriveError = class extends Error {
+	code;
+	status;
+	requestId;
+	details;
+	constructor(code, options = {}) {
+		super(code in DRIVE_API_ERROR_MESSAGES ? DRIVE_API_ERROR_MESSAGES[code] : SDK_MESSAGES[code]);
+		this.name = "DriveError";
+		this.code = code;
+		this.status = options.status ?? null;
+		this.requestId = options.requestId ?? null;
+		this.details = Object.freeze({});
+	}
+};
+//#endregion
+//#region src/internal/client.ts
+const ERROR_BODY_LIMIT = 16 * 1024;
+const SUCCESS_BODY_LIMIT = 256 * 1024;
+const RESPONSE_CHUNK_LIMIT = 256;
+const RESPONSE_DEADLINE_MILLISECONDS = 5e3;
+const DEFAULT_REQUEST_TIMEOUT_MILLISECONDS = 3e4;
+const MAX_REQUEST_TIMEOUT_MILLISECONDS = 12e4;
+const REQUEST_ID = /^[A-Za-z0-9_-]{16,128}$/;
+const COLLECTION_ETAG = /^"drive\.permission-collection\.v1\.(0|[1-9][0-9]*)"$/;
+const GRANT_ETAG = /^"drive\.permission-grant\.v1\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"$/;
+const LIST_ETAG = /^"drive\.permission-list\.v1\.[0-9a-f]{64}"$/;
+const ITEM_ID = /^drive\.item\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const WORKSPACE_ID = /^drive\.workspace\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const VOLUME_ID = /^drive\.volume\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const GRANT_ID = /^drive\.grant\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const UPLOAD_ID = /^drive\.upload\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const CURSOR = /^drive\.cursor\.v1\.[A-Za-z0-9_-]+$/;
+const AUTH_ID = /^[A-Za-z0-9_-]{1,128}$/;
+const PERMISSION_ACTIONS = Object.freeze([
+	"items:content:read",
+	"items:create",
+	"items:delete",
+	"items:metadata:read",
+	"items:permissions:read",
+	"items:update"
+]);
+const EFFECTIVE_ACTIONS = Object.freeze([
+	"items:content:read",
+	"items:create",
+	"items:delete",
+	"items:metadata:read",
+	"items:permissions:manage",
+	"items:permissions:read",
+	"items:update"
+]);
+const IDEMPOTENCY_KEY = /^[A-Za-z0-9_-]{16,128}$/;
+const MAX_UPLOAD_BYTE_LENGTH = 33554432e4;
+const UPLOAD_QUOTA_EXPIRY_MILLISECONDS = 864e5;
+function createDriveClientInternal(config) {
+	let runtime;
+	try {
+		runtime = Object.freeze({
+			baseUrl: parseBaseUrl(config.baseUrl),
+			fetchImplementation: config.fetch ?? globalThis.fetch,
+			getCredential: config.getCredential,
+			timeoutMilliseconds: parseTimeoutMilliseconds(config.timeoutMilliseconds)
+		});
+	} catch {
+		throw new DriveError("invalid_input");
+	}
+	if (typeof runtime.fetchImplementation !== "function" || typeof runtime.getCredential !== "function") throw new DriveError("invalid_input");
+	return Object.freeze({
+		listFolderChildren: (input) => listFolderChildren(runtime, input),
+		createFolder: (input) => createFolder(runtime, input),
+		listItemPermissions: (input) => listItemPermissions(runtime, input),
+		readEffectiveItemPermissions: (input) => readEffectiveItemPermissions(runtime, input),
+		createItemPermission: (input) => createItemPermission(runtime, input),
+		updateItemPermission: (input) => updateItemPermission(runtime, input),
+		revokeItemPermission: (input) => revokeItemPermission(runtime, input),
+		createUpload: (input) => createUpload(runtime, input),
+		abortUpload: (input) => abortUpload(runtime, input)
+	});
+}
+async function listFolderChildren(runtime, input) {
+	const validated = validatePageInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/items/{itemId}/children", {
+		...operationOptions("listFolderChildren", { params: {
+			path: resourcePath(validated),
+			query: pageQuery(validated)
+		} }),
+		...requestOptions
+	}), [200], (value) => isFolderPage(value, validated.workspaceId, validated.itemId));
+}
+async function createFolder(runtime, input) {
+	const validated = validateCreateFolderInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/items/{itemId}/children", {
+		...operationOptions("createFolder", {
+			params: {
+				path: resourcePath(validated),
+				header: { "Idempotency-Key": validated.idempotencyKey }
+			},
+			body: { name: validated.name }
+		}),
+		...requestOptions
+	}), [200, 201], (value) => isFolderItem(value) && value.workspaceId === validated.workspaceId && value.parentItemId === validated.itemId && value.kind === "folder" && value.name === validated.name);
+}
+async function listItemPermissions(runtime, input) {
+	const validated = validatePageInput(input);
+	return execute(runtime, validated.signal, 412, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/items/{itemId}/permissions", {
+		...operationOptions("listItemPermissions", { params: {
+			path: resourcePath(validated),
+			query: pageQuery(validated)
+		} }),
+		...requestOptions
+	}), [200], (value, _status, headers) => isPermissionPage(value, headers, validated.itemId));
+}
+async function readEffectiveItemPermissions(runtime, input) {
+	const validated = validateResourceInput(input);
+	return execute(runtime, validated.signal, 412, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/items/{itemId}/permissions/effective", {
+		...operationOptions("readEffectiveItemPermissions", { params: { path: resourcePath(validated) } }),
+		...requestOptions
+	}), [200], (value) => isEffectivePermissionResponse(value, validated.itemId));
+}
+async function createItemPermission(runtime, input) {
+	const validated = validateCreatePermissionInput(input);
+	return execute(runtime, validated.signal, 412, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/items/{itemId}/permissions", {
+		...operationOptions("createItemPermission", {
+			params: {
+				path: resourcePath(validated),
+				header: {
+					"Idempotency-Key": validated.idempotencyKey,
+					"If-Match": validated.ifMatch
+				}
+			},
+			body: {
+				grantee: validated.grantee,
+				actions: validated.actions,
+				expiresAtEpochMilliseconds: validated.expiresAtEpochMilliseconds
+			}
+		}),
+		...requestOptions
+	}), [200, 201], (value, status, headers) => isPermissionMutation(value, validated.itemId) && (status === 201 && value.outcome === "committed" || status === 200 && value.outcome === "replayed") && (status === 200 || value.grant.availability !== "revoked") && mutationValidatorsAreCoherent(headers));
+}
+async function updateItemPermission(runtime, input) {
+	const validated = validateUpdatePermissionInput(input);
+	const body = {};
+	if (validated.actions !== void 0) body.actions = validated.actions;
+	if (validated.expiresAtEpochMilliseconds !== void 0) body.expiresAtEpochMilliseconds = validated.expiresAtEpochMilliseconds;
+	return execute(runtime, validated.signal, 412, (api, requestOptions) => api.PATCH("/api/v1/workspaces/{workspaceId}/items/{itemId}/permissions/{grantId}", {
+		...operationOptions("updateItemPermission", {
+			params: {
+				path: {
+					...resourcePath(validated),
+					grantId: validated.grantId
+				},
+				header: {
+					"Idempotency-Key": validated.idempotencyKey,
+					"If-Match": validated.ifMatch
+				}
+			},
+			body
+		}),
+		...requestOptions
+	}), [200], (value, _status, headers) => isPermissionMutation(value, validated.itemId, validated.grantId) && value.grant.availability !== "revoked" && mutationValidatorsAreCoherent(headers));
+}
+async function revokeItemPermission(runtime, input) {
+	const validated = validateGrantMutationInput(input);
+	return execute(runtime, validated.signal, 412, (api, requestOptions) => api.DELETE("/api/v1/workspaces/{workspaceId}/items/{itemId}/permissions/{grantId}", {
+		...operationOptions("revokeItemPermission", { params: {
+			path: {
+				...resourcePath(validated),
+				grantId: validated.grantId
+			},
+			header: {
+				"Idempotency-Key": validated.idempotencyKey,
+				"If-Match": validated.ifMatch
+			}
+		} }),
+		...requestOptions
+	}), [200], (value, _status, headers) => isPermissionMutation(value, validated.itemId, validated.grantId) && value.grant.availability === "revoked" && parseCollectionEtag(headers.get("drive-permission-collection-etag") ?? "") !== void 0 && headers.get("drive-permission-grant-etag") === null);
+}
+async function createUpload(runtime, input) {
+	const validated = validateCreateUploadInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads", {
+		...operationOptions("createUpload", {
+			params: {
+				path: { workspaceId: validated.workspaceId },
+				header: { "Idempotency-Key": validated.idempotencyKey }
+			},
+			body: {
+				parentItemId: validated.parentItemId,
+				expectedByteLength: validated.expectedByteLength
+			}
+		}),
+		...requestOptions
+	}), [200, 201], (value) => isUploadQuotaReservation(value) && value.workspaceId === validated.workspaceId && value.parentItemId === validated.parentItemId && value.expectedByteLength === validated.expectedByteLength && value.state === "reserved" && value.terminalReason === null && value.terminalAtEpochMilliseconds === null, true);
+}
+async function abortUpload(runtime, input) {
+	const validated = validateAbortUploadInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.DELETE("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}", {
+		...operationOptions("abortUpload", { params: { path: {
+			workspaceId: validated.workspaceId,
+			uploadId: validated.uploadId
+		} } }),
+		...requestOptions
+	}), [200], (value) => isUploadQuotaReservation(value) && value.workspaceId === validated.workspaceId && value.uploadId === validated.uploadId && value.state === "released" && value.terminalReason === "aborted" && value.terminalAtEpochMilliseconds !== null);
+}
+async function execute(runtime, signal, preconditionStatus, send, successStatuses, guard, allowsQuotaExceeded = false) {
+	const operation = createOperationSignal(signal, runtime.timeoutMilliseconds);
+	try {
+		const operationSignal = operation.signal;
+		throwIfAborted(operationSignal);
+		const credential = await obtainCredential(runtime.getCredential, operationSignal);
+		let capturedResponse;
+		await send(createClient({
+			baseUrl: runtime.baseUrl,
+			fetch: async (request) => {
+				try {
+					const response = await raceWithAbort(runtime.fetchImplementation(request), operationSignal);
+					if (!(response instanceof Response)) throw new DriveError("invalid_response");
+					capturedResponse = response;
+				} catch (error) {
+					if (error instanceof DriveError) throw error;
+					throw operationSignal.aborted ? new DriveError("aborted") : new DriveError("network_error");
+				}
+				return new Response(null, { status: 204 });
+			}
+		}), {
+			cache: "no-store",
+			credentials: "omit",
+			headers: new Headers({ authorization: `Bearer ${credential}` }),
+			signal: operationSignal
+		});
+		if (!capturedResponse) throw new DriveError("network_error");
+		const response = capturedResponse;
+		const requestId = safeRequestId(response.headers.get("x-request-id"));
+		if (requestId === null) {
+			cancelResponse(response);
+			throw new DriveError("invalid_response", { status: response.status });
+		}
+		if (!successStatuses.includes(response.status)) throw await normalizeError(response, requestId, operationSignal, preconditionStatus, allowsQuotaExceeded);
+		const { value } = await parseBoundedJson(response, SUCCESS_BODY_LIMIT, response.status, requestId, operationSignal);
+		const status = response.status;
+		if (!guard(value, status, response.headers)) throw new DriveError("invalid_response", {
+			status,
+			requestId
+		});
+		return Object.freeze({
+			data: value,
+			status,
+			requestId,
+			validators: readValidators(response.headers)
+		});
+	} catch (error) {
+		if (operation.didTimeout()) throw new DriveError("timeout");
+		if (error instanceof DriveError) throw error;
+		throw operation.signal.aborted ? new DriveError("aborted") : new DriveError("network_error");
+	} finally {
+		operation.dispose();
+	}
+}
+function parseTimeoutMilliseconds(value) {
+	if (value === void 0) return DEFAULT_REQUEST_TIMEOUT_MILLISECONDS;
+	if (!Number.isSafeInteger(value) || value < 1 || value > MAX_REQUEST_TIMEOUT_MILLISECONDS) throw new DriveError("invalid_input");
+	return value;
+}
+function createOperationSignal(callerSignal, timeoutMilliseconds) {
+	const controller = new AbortController();
+	let timedOut = false;
+	const onAbort = () => controller.abort();
+	if (callerSignal?.aborted) controller.abort();
+	else callerSignal?.addEventListener("abort", onAbort, { once: true });
+	const timeout = setTimeout(() => {
+		timedOut = true;
+		controller.abort();
+	}, timeoutMilliseconds);
+	return {
+		signal: controller.signal,
+		didTimeout: () => timedOut,
+		dispose: () => {
+			clearTimeout(timeout);
+			callerSignal?.removeEventListener("abort", onAbort);
+		}
+	};
+}
+function parseBaseUrl(value) {
+	if (typeof value !== "string") throw new TypeError("Drive base URL is invalid");
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new TypeError("Drive base URL is invalid");
+	}
+	const localHttp = url.protocol === "http:" && [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+	if (url.protocol !== "https:" && !localHttp || url.username || url.password || url.search || url.hash || !url.host) throw new TypeError("Drive base URL is invalid");
+	return joinURL(url.origin, url.pathname);
+}
+async function obtainCredential(provider, signal) {
+	throwIfAborted(signal);
+	let credential;
+	try {
+		credential = await raceWithAbort(provider({ signal }), signal);
+	} catch (error) {
+		if (error instanceof DriveError && error.code === "aborted") throw error;
+		throw signal.aborted ? new DriveError("aborted") : new DriveError("credential_unavailable");
+	}
+	if (typeof credential !== "string" || credential.length < 1 || credential.length > 16384 || !/^[\x21-\x7e]+$/.test(credential)) throw new DriveError("credential_unavailable");
+	return credential;
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw new DriveError("aborted");
+}
+async function raceWithAbort(promise, signal) {
+	throwIfAborted(signal);
+	let removeAbort = () => {};
+	const aborted = new Promise((_, reject) => {
+		const onAbort = () => reject(new DriveError("aborted"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbort = () => signal.removeEventListener("abort", onAbort);
+	});
+	try {
+		return await Promise.race([promise, aborted]);
+	} finally {
+		removeAbort();
+	}
+}
+function validateResourceInput(value) {
+	const input = captureRecord(value, ["workspaceId", "itemId"], ["signal"]);
+	const workspaceId = input.workspaceId;
+	const itemId = input.itemId;
+	const signal = validateSignal(input.signal);
+	if (typeof workspaceId !== "string" || !WORKSPACE_ID.test(workspaceId) || typeof itemId !== "string" || !ITEM_ID.test(itemId)) throw new DriveError("invalid_input");
+	return {
+		workspaceId,
+		itemId,
+		...signal === void 0 ? {} : { signal }
+	};
+}
+function validatePageInput(value) {
+	const input = captureRecord(value, ["workspaceId", "itemId"], [
+		"signal",
+		"limit",
+		"cursor"
+	]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	const limit = input.limit;
+	const cursor = input.cursor;
+	if (limit !== void 0 && (!Number.isSafeInteger(limit) || typeof limit !== "number" || limit < 1 || limit > 50) || cursor !== void 0 && (typeof cursor !== "string" || cursor.length > 699 || !CURSOR.test(cursor))) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		...limit === void 0 ? {} : { limit },
+		...cursor === void 0 ? {} : { cursor }
+	};
+}
+function validateCreateFolderInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"name",
+		"idempotencyKey"
+	], ["signal"]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	if (!isSafeFilename(input.name) || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		name: input.name,
+		idempotencyKey: input.idempotencyKey
+	};
+}
+function validateCreatePermissionInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"grantee",
+		"actions",
+		"expiresAtEpochMilliseconds",
+		"ifMatch",
+		"idempotencyKey"
+	], ["signal"]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	const grantee = validateGrantee(input.grantee);
+	const actions = validateInputActions(input.actions);
+	const expiry = input.expiresAtEpochMilliseconds;
+	if (!isExpiry(expiry) || typeof input.ifMatch !== "string" || parseCollectionEtag(input.ifMatch) === void 0 || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		grantee,
+		actions,
+		expiresAtEpochMilliseconds: expiry,
+		ifMatch: input.ifMatch,
+		idempotencyKey: input.idempotencyKey
+	};
+}
+function validateGrantMutationInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"grantId",
+		"ifMatch",
+		"idempotencyKey"
+	], ["signal"]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	if (typeof input.grantId !== "string" || !GRANT_ID.test(input.grantId) || typeof input.ifMatch !== "string" || parseGrantEtag(input.ifMatch) === void 0 || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		grantId: input.grantId,
+		ifMatch: input.ifMatch,
+		idempotencyKey: input.idempotencyKey
+	};
+}
+function validateUpdatePermissionInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"grantId",
+		"ifMatch",
+		"idempotencyKey"
+	], [
+		"signal",
+		"actions",
+		"expiresAtEpochMilliseconds"
+	]);
+	const mutation = validateGrantMutationInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		grantId: input.grantId,
+		ifMatch: input.ifMatch,
+		idempotencyKey: input.idempotencyKey,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	const actions = input.actions === void 0 ? void 0 : validateInputActions(input.actions);
+	const expiry = input.expiresAtEpochMilliseconds;
+	if (actions === void 0 && expiry === void 0 || expiry !== void 0 && !isExpiry(expiry)) throw new DriveError("invalid_input");
+	return {
+		...mutation,
+		...actions === void 0 ? {} : { actions },
+		...expiry === void 0 ? {} : { expiresAtEpochMilliseconds: expiry }
+	};
+}
+function validateCreateUploadInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"parentItemId",
+		"expectedByteLength",
+		"idempotencyKey"
+	], ["signal"]);
+	const signal = validateSignal(input.signal);
+	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.parentItemId !== "string" || !ITEM_ID.test(input.parentItemId) || typeof input.expectedByteLength !== "number" || !Number.isSafeInteger(input.expectedByteLength) || input.expectedByteLength < 0 || input.expectedByteLength > MAX_UPLOAD_BYTE_LENGTH || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	return {
+		workspaceId: input.workspaceId,
+		parentItemId: input.parentItemId,
+		expectedByteLength: input.expectedByteLength,
+		idempotencyKey: input.idempotencyKey,
+		...signal === void 0 ? {} : { signal }
+	};
+}
+function validateAbortUploadInput(value) {
+	const input = captureRecord(value, ["workspaceId", "uploadId"], ["signal"]);
+	const signal = validateSignal(input.signal);
+	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.uploadId !== "string" || !UPLOAD_ID.test(input.uploadId)) throw new DriveError("invalid_input");
+	return {
+		workspaceId: input.workspaceId,
+		uploadId: input.uploadId,
+		...signal === void 0 ? {} : { signal }
+	};
+}
+function captureRecord(value, required, optional) {
+	try {
+		if (typeof value !== "object" && typeof value !== "function" || value === null || Array.isArray(value)) throw new DriveError("invalid_input");
+		const descriptors = Object.getOwnPropertyDescriptors(value);
+		const keys = Reflect.ownKeys(descriptors);
+		const allowed = new Set([...required, ...optional]);
+		if (keys.some((key) => typeof key !== "string" || !allowed.has(key)) || required.some((key) => !Object.hasOwn(descriptors, key))) throw new DriveError("invalid_input");
+		const result = {};
+		for (const key of keys) {
+			if (typeof key !== "string") throw new DriveError("invalid_input");
+			const descriptor = descriptors[key];
+			if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new DriveError("invalid_input");
+			result[key] = descriptor.value;
+		}
+		return result;
+	} catch (error) {
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("invalid_input");
+	}
+}
+function validateSignal(value) {
+	if (value === void 0) return void 0;
+	if (!(value instanceof AbortSignal)) throw new DriveError("invalid_input");
+	return value;
+}
+function validateGrantee(value) {
+	const type = captureRecord(value, ["type"], ["userId", "teamId"]);
+	if (type.type === "user") {
+		const user = captureRecord(value, ["type", "userId"], []);
+		if (typeof user.userId === "string" && AUTH_ID.test(user.userId)) return {
+			type: "user",
+			userId: user.userId
+		};
+	}
+	if (type.type === "team") {
+		const team = captureRecord(value, ["type", "teamId"], []);
+		if (typeof team.teamId === "string" && AUTH_ID.test(team.teamId)) return {
+			type: "team",
+			teamId: team.teamId
+		};
+	}
+	throw new DriveError("invalid_input");
+}
+function validateInputActions(value) {
+	const actions = captureArray(value);
+	if (actions.length < 1 || actions.length > PERMISSION_ACTIONS.length || new Set(actions).size !== actions.length || !actions.every((action) => PERMISSION_ACTIONS.includes(action))) throw new DriveError("invalid_input");
+	return actions;
+}
+function captureArray(value) {
+	try {
+		if (!Array.isArray(value)) throw new DriveError("invalid_input");
+		const descriptors = Object.getOwnPropertyDescriptors(value);
+		if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string")) throw new DriveError("invalid_input");
+		const result = [];
+		for (let index = 0; index < value.length; index += 1) {
+			const descriptor = descriptors[String(index)];
+			if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new DriveError("invalid_input");
+			result.push(descriptor.value);
+		}
+		if (Reflect.ownKeys(descriptors).length !== value.length + 1) throw new DriveError("invalid_input");
+		return result;
+	} catch (error) {
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("invalid_input");
+	}
+}
+function isIdempotencyKey(value) {
+	return typeof value === "string" && IDEMPOTENCY_KEY.test(value);
+}
+function isExpiry(value) {
+	return value === null || isSafeInteger(value);
+}
+function resourcePath(input) {
+	return {
+		workspaceId: input.workspaceId,
+		itemId: input.itemId
+	};
+}
+function pageQuery(input) {
+	return {
+		...input.limit === void 0 ? {} : { limit: input.limit },
+		...input.cursor === void 0 ? {} : { cursor: input.cursor }
+	};
+}
+function operationOptions(_operationId, options) {
+	return options;
+}
+async function normalizeError(response, headerRequestId, signal, preconditionStatus, allowsQuotaExceeded) {
+	let parsed;
+	try {
+		parsed = await parseBoundedJson(response, ERROR_BODY_LIMIT, response.status, headerRequestId, signal);
+	} catch (error) {
+		if (error instanceof DriveError && error.code === "aborted") return error;
+		return new DriveError("invalid_response", {
+			status: response.status,
+			requestId: headerRequestId
+		});
+	}
+	const value = parsed.value;
+	if (!isExactRecord(value, ["error"]) || !isExactRecord(value.error, [
+		"code",
+		"message",
+		"requestId",
+		"details"
+	])) return new DriveError("invalid_response", {
+		status: response.status,
+		requestId: headerRequestId
+	});
+	const envelope = value.error;
+	if (typeof envelope.code !== "string" || !DRIVE_API_ERROR_CODES.includes(envelope.code) || envelope.message !== DRIVE_API_ERROR_MESSAGES[envelope.code] || !REQUEST_ID.test(String(envelope.requestId)) || envelope.requestId !== headerRequestId || !isExactRecord(envelope.details, []) || !errorStatusMatches(envelope.code, response.status, preconditionStatus, allowsQuotaExceeded) || parsed.text !== JSON.stringify(value)) return new DriveError("invalid_response", {
+		status: response.status,
+		requestId: headerRequestId
+	});
+	return new DriveError(envelope.code, {
+		status: response.status,
+		requestId: envelope.requestId
+	});
+}
+function errorStatusMatches(code, status, preconditionStatus, allowsQuotaExceeded) {
+	if (code === "quota_exceeded" && !allowsQuotaExceeded) return false;
+	return {
+		authentication_required: [401],
+		identity_authority_unavailable: [503],
+		permission_denied: [403],
+		resource_not_found: [404],
+		invalid_request: [422],
+		invalid_pagination_cursor: [422],
+		invalid_idempotency_key: [422],
+		precondition_failed: [preconditionStatus],
+		idempotency_conflict: [409],
+		quota_exceeded: [409],
+		service_unavailable: [503],
+		internal_error: [500]
+	}[code].includes(status);
+}
+async function parseBoundedJson(response, maximumBytes, status, requestId, signal) {
+	if (!response.body) throw new DriveError("invalid_response", {
+		status,
+		requestId
+	});
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	let size = 0;
+	let chunks = 0;
+	let text = "";
+	const contentLength = response.headers.get("content-length");
+	if (contentLength !== null && (!/^(?:0|[1-9][0-9]*)$/.test(contentLength) || Number(contentLength) > maximumBytes)) {
+		reader.cancel().catch(() => {});
+		throw new DriveError("invalid_response", {
+			status,
+			requestId
+		});
+	}
+	const deadline = new AbortController();
+	const timeout = setTimeout(() => deadline.abort(), RESPONSE_DEADLINE_MILLISECONDS);
+	try {
+		while (true) {
+			if (signal?.aborted) throw new DriveError("aborted");
+			const { done, value } = await readResponseChunk(reader, signal, deadline.signal);
+			if (done) break;
+			chunks += 1;
+			size += value.byteLength;
+			if (chunks > RESPONSE_CHUNK_LIMIT || size > maximumBytes) throw new DriveError("invalid_response", {
+				status,
+				requestId
+			});
+			text += decoder.decode(value, { stream: true });
+		}
+		text += decoder.decode();
+		return {
+			value: JSON.parse(text),
+			text
+		};
+	} catch (error) {
+		if (error instanceof DriveError) {
+			if (error.code === "aborted" || signal?.aborted) throw new DriveError("aborted");
+			throw error;
+		}
+		throw new DriveError("invalid_response", {
+			status,
+			requestId
+		});
+	} finally {
+		clearTimeout(timeout);
+		reader.cancel().catch(() => {});
+	}
+}
+async function readResponseChunk(reader, operationSignal, deadlineSignal) {
+	if (operationSignal?.aborted) throw new DriveError("aborted");
+	if (deadlineSignal.aborted) throw new DriveError("invalid_response");
+	let removeOperationAbort = () => {};
+	let removeDeadlineAbort = () => {};
+	const operationAbort = new Promise((_, reject) => {
+		if (!operationSignal) return;
+		const onAbort = () => reject(new DriveError("aborted"));
+		operationSignal.addEventListener("abort", onAbort, { once: true });
+		removeOperationAbort = () => operationSignal.removeEventListener("abort", onAbort);
+	});
+	const deadlineAbort = new Promise((_, reject) => {
+		const onAbort = () => reject(new DriveError("invalid_response"));
+		deadlineSignal.addEventListener("abort", onAbort, { once: true });
+		removeDeadlineAbort = () => deadlineSignal.removeEventListener("abort", onAbort);
+	});
+	try {
+		return await Promise.race([
+			reader.read(),
+			operationAbort,
+			deadlineAbort
+		]);
+	} finally {
+		removeOperationAbort();
+		removeDeadlineAbort();
+	}
+}
+function cancelResponse(response) {
+	response.body?.cancel().catch(() => {});
+}
+function safeRequestId(value) {
+	return value !== null && REQUEST_ID.test(value) ? value : null;
+}
+function readValidators(headers) {
+	const etag = headers.get("etag");
+	const permissionCollectionEtag = headers.get("drive-permission-collection-etag");
+	const permissionGrantEtag = headers.get("drive-permission-grant-etag");
+	return Object.freeze({
+		...etag !== null && LIST_ETAG.test(etag) ? { etag } : {},
+		...permissionCollectionEtag !== null && parseCollectionEtag(permissionCollectionEtag) !== void 0 ? { permissionCollectionEtag } : {},
+		...permissionGrantEtag !== null && parseGrantEtag(permissionGrantEtag) !== void 0 ? { permissionGrantEtag } : {}
+	});
+}
+function isFolderPage(value, workspaceId, parentItemId) {
+	if (!(isExactRecord(value, ["items", "nextCursor"]) && Array.isArray(value.items) && value.items.length <= 50 && value.items.every(isFolderItem) && (value.nextCursor === null || typeof value.nextCursor === "string" && value.nextCursor.length <= 699 && CURSOR.test(value.nextCursor)))) return false;
+	return value.items.every((item) => item.workspaceId === workspaceId && item.parentItemId === parentItemId) && isStrictlyOrdered(value.items, (item) => item.itemId);
+}
+function isFolderItem(value) {
+	return isExactRecord(value, [
+		"workspaceId",
+		"volumeId",
+		"itemId",
+		"parentItemId",
+		"kind",
+		"name",
+		"visibility",
+		"revision"
+	]) && typeof value.workspaceId === "string" && WORKSPACE_ID.test(value.workspaceId) && typeof value.volumeId === "string" && VOLUME_ID.test(value.volumeId) && typeof value.itemId === "string" && ITEM_ID.test(value.itemId) && typeof value.parentItemId === "string" && ITEM_ID.test(value.parentItemId) && (value.kind === "file" || value.kind === "folder") && isSafeFilename(value.name) && (value.visibility === "workspace" || value.visibility === "restricted") && isSafeInteger(value.revision);
+}
+function isPermissionPage(value, headers, targetItemId) {
+	if (!(isExactRecord(value, [
+		"items",
+		"nextCursor",
+		"collectionRevision",
+		"collectionEtag"
+	]) && Array.isArray(value.items) && value.items.length <= 50 && value.items.every(isPermissionGrant) && (value.nextCursor === null || typeof value.nextCursor === "string" && value.nextCursor.length <= 699 && CURSOR.test(value.nextCursor)) && isSafeInteger(value.collectionRevision) && typeof value.collectionEtag === "string" && parseCollectionEtag(value.collectionEtag) === value.collectionRevision)) return false;
+	const collectionHeader = headers.get("drive-permission-collection-etag");
+	const representationEtag = headers.get("etag");
+	const collectionRevision = value.collectionRevision;
+	if (!isSafeInteger(collectionRevision)) return false;
+	return collectionHeader === value.collectionEtag && representationEtag !== null && LIST_ETAG.test(representationEtag) && value.items.every((grant) => (grant.source === "direct" ? grant.sourceItemId === targetItemId : grant.sourceItemId !== targetItemId) && grant.etag === permissionGrantEtag(collectionRevision, grant.revision)) && isStrictlyOrdered(value.items, (grant) => `${grant.sourceItemId}\0${grant.grantId}`);
+}
+function isPermissionGrant(value) {
+	return isExactRecord(value, [
+		"source",
+		"sourceItemId",
+		"grantId",
+		"grantee",
+		"actions",
+		"availability",
+		"expiresAtEpochMilliseconds",
+		"revision",
+		"etag"
+	]) && (value.source === "direct" || value.source === "inherited") && typeof value.sourceItemId === "string" && ITEM_ID.test(value.sourceItemId) && typeof value.grantId === "string" && GRANT_ID.test(value.grantId) && isGrantee(value.grantee) && isPermissionActions(value.actions) && [
+		"active",
+		"expired",
+		"revoked"
+	].includes(String(value.availability)) && (value.expiresAtEpochMilliseconds === null || isSafeInteger(value.expiresAtEpochMilliseconds)) && isSafeInteger(value.revision) && typeof value.etag === "string" && GRANT_ETAG.test(value.etag);
+}
+function isGrantee(value) {
+	return isExactRecord(value, ["type", "userId"]) && value.type === "user" && typeof value.userId === "string" && AUTH_ID.test(value.userId) || isExactRecord(value, ["type", "teamId"]) && value.type === "team" && typeof value.teamId === "string" && AUTH_ID.test(value.teamId);
+}
+function isPermissionActions(value) {
+	return Array.isArray(value) && value.length >= 1 && value.length <= 6 && new Set(value).size === value.length && value.every((action) => PERMISSION_ACTIONS.includes(action)) && value.every((action, index) => index === 0 || PERMISSION_ACTIONS.indexOf(action) > PERMISSION_ACTIONS.indexOf(value[index - 1]));
+}
+function isPermissionMutation(value, targetItemId, expectedGrantId) {
+	if (!isExactRecord(value, [
+		"outcome",
+		"grant",
+		"collectionRevision"
+	]) || value.outcome !== "committed" && value.outcome !== "replayed" || !isSafeInteger(value.collectionRevision)) return false;
+	const grant = value.grant;
+	return isExactRecord(grant, [
+		"source",
+		"sourceItemId",
+		"grantId",
+		"grantee",
+		"actions",
+		"availability",
+		"expiresAtEpochMilliseconds",
+		"revision"
+	]) && grant.source === "direct" && typeof grant.sourceItemId === "string" && grant.sourceItemId === targetItemId && typeof grant.grantId === "string" && GRANT_ID.test(grant.grantId) && (expectedGrantId === void 0 || grant.grantId === expectedGrantId) && isGrantee(grant.grantee) && isPermissionActions(grant.actions) && [
+		"active",
+		"expired",
+		"revoked"
+	].includes(String(grant.availability)) && (grant.expiresAtEpochMilliseconds === null || isSafeInteger(grant.expiresAtEpochMilliseconds)) && isSafeInteger(grant.revision);
+}
+function isEffectivePermissionResponse(value, targetItemId) {
+	if (!isExactRecord(value, ["actions"]) || !Array.isArray(value.actions) || value.actions.length !== 7) return false;
+	for (let index = 0; index < value.actions.length; index += 1) {
+		const action = value.actions[index];
+		if (action === void 0 || !isExactRecord(action, [
+			"action",
+			"allowed",
+			"basis",
+			"sourceItemId",
+			"grantId"
+		]) || action.action !== EFFECTIVE_ACTIONS[index] || typeof action.allowed !== "boolean" || !(action.basis === null || [
+			"workspace_visibility",
+			"restricted_administrator_bypass",
+			"direct_grant",
+			"inherited_grant"
+		].includes(String(action.basis))) || !(action.sourceItemId === null || typeof action.sourceItemId === "string" && ITEM_ID.test(action.sourceItemId)) || !(action.grantId === null || typeof action.grantId === "string" && GRANT_ID.test(action.grantId)) || !effectiveSourceIsCoherent(action, targetItemId)) return false;
+	}
+	return true;
+}
+function isUploadQuotaReservation(value) {
+	return isExactRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"parentItemId",
+		"expectedByteLength",
+		"state",
+		"terminalReason",
+		"createdAtEpochMilliseconds",
+		"expiresAtEpochMilliseconds",
+		"terminalAtEpochMilliseconds"
+	]) && typeof value.workspaceId === "string" && WORKSPACE_ID.test(value.workspaceId) && typeof value.uploadId === "string" && UPLOAD_ID.test(value.uploadId) && typeof value.parentItemId === "string" && ITEM_ID.test(value.parentItemId) && typeof value.expectedByteLength === "number" && Number.isSafeInteger(value.expectedByteLength) && value.expectedByteLength >= 0 && value.expectedByteLength <= MAX_UPLOAD_BYTE_LENGTH && (value.state === "reserved" || value.state === "converted" || value.state === "released") && (value.terminalReason === null || value.terminalReason === "completed" || value.terminalReason === "aborted" || value.terminalReason === "failed" || value.terminalReason === "expired") && isSafeInteger(value.createdAtEpochMilliseconds) && isSafeInteger(value.expiresAtEpochMilliseconds) && value.expiresAtEpochMilliseconds - value.createdAtEpochMilliseconds === UPLOAD_QUOTA_EXPIRY_MILLISECONDS && (value.terminalAtEpochMilliseconds === null || isSafeInteger(value.terminalAtEpochMilliseconds) && value.terminalAtEpochMilliseconds >= value.createdAtEpochMilliseconds);
+}
+function effectiveSourceIsCoherent(action, targetItemId) {
+	if (!action.allowed) return action.basis === null && action.sourceItemId === null && action.grantId === null;
+	if (action.basis === "workspace_visibility" || action.basis === "restricted_administrator_bypass") return action.sourceItemId === null && action.grantId === null;
+	if (action.basis === "direct_grant") return action.sourceItemId === targetItemId && typeof action.grantId === "string";
+	if (action.basis === "inherited_grant") return typeof action.sourceItemId === "string" && action.sourceItemId !== targetItemId && typeof action.grantId === "string";
+	return false;
+}
+function mutationValidatorsAreCoherent(headers) {
+	const collection = headers.get("drive-permission-collection-etag");
+	const grant = headers.get("drive-permission-grant-etag");
+	const collectionRevision = collection === null ? void 0 : parseCollectionEtag(collection);
+	if (collectionRevision === void 0) return false;
+	if (grant === null) return true;
+	const currentGrant = parseGrantEtag(grant);
+	return currentGrant !== void 0 && currentGrant[0] === collectionRevision;
+}
+function parseCollectionEtag(value) {
+	const match = COLLECTION_ETAG.exec(value);
+	if (!match) return void 0;
+	const revision = Number(match[1]);
+	return Number.isSafeInteger(revision) ? revision : void 0;
+}
+function parseGrantEtag(value) {
+	const match = GRANT_ETAG.exec(value);
+	if (!match) return void 0;
+	const collectionRevision = Number(match[1]);
+	const grantRevision = Number(match[2]);
+	return Number.isSafeInteger(collectionRevision) && Number.isSafeInteger(grantRevision) ? [collectionRevision, grantRevision] : void 0;
+}
+function permissionGrantEtag(collectionRevision, grantRevision) {
+	return `"drive.permission-grant.v1.${collectionRevision}.${grantRevision}"`;
+}
+function isSafeFilename(value) {
+	if (typeof value !== "string" || value.length === 0 || value.length > 510 || value.normalize("NFC") !== value || value.endsWith(".") || value.endsWith(" ") || filenameIsReserved(value)) return false;
+	let codePoints = 0;
+	let bytes = 0;
+	for (const character of value) {
+		const point = character.codePointAt(0);
+		if (point === void 0 || point === 47 || point === 92 || point <= 31 || point >= 127 && point <= 159 || point === 8232 || point === 8233 || point >= 55296 && point <= 57343) return false;
+		codePoints += 1;
+		bytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+		if (codePoints > 255 || bytes > 255) return false;
+	}
+	return true;
+}
+function filenameIsReserved(value) {
+	const base = value.split(".", 1)[0].toUpperCase();
+	return value === "." || value === ".." || [
+		"CON",
+		"PRN",
+		"AUX",
+		"NUL",
+		"CLOCK$",
+		"CONIN$",
+		"CONOUT$"
+	].includes(base) || /^COM[1-9]$/.test(base) || /^LPT[1-9]$/.test(base);
+}
+function isStrictlyOrdered(values, key) {
+	return values.every((value, index) => index === 0 || key(values[index - 1]) < key(value));
+}
+function isSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isExactRecord(value, keys) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+//#endregion
+//#region src/client.ts
+function createDriveClient(config) {
+	return createDriveClientInternal(config);
+}
+//#endregion
+export { createDriveClient };