@finueva/drive 0.2.0 → 0.5.0

package/dist/client.js

@@ -8,8 +8,10 @@ const DRIVE_API_ERROR_CODES = Object.freeze([
 	"invalid_pagination_cursor",
 	"invalid_idempotency_key",
 	"precondition_failed",
+	"range_not_satisfiable",
 	"idempotency_conflict",
 	"quota_exceeded",
+	"upload_recovery_required",
 	"service_unavailable",
 	"internal_error"
 ]);
@@ -22,8 +24,10 @@ const DRIVE_API_ERROR_MESSAGES = Object.freeze({
 	invalid_pagination_cursor: "The pagination cursor is invalid.",
 	invalid_idempotency_key: "The idempotency key is invalid.",
 	precondition_failed: "The request precondition failed.",
+	range_not_satisfiable: "The requested byte range is not satisfiable.",
 	idempotency_conflict: "The idempotency key conflicts with an earlier request.",
 	quota_exceeded: "The workspace storage quota would be exceeded.",
+	upload_recovery_required: "The upload requires recovery before it can continue.",
 	service_unavailable: "The service is temporarily unavailable.",
 	internal_error: "The request could not be completed."
 });
@@ -59,6 +63,7 @@ const REQUEST_ID = /^[A-Za-z0-9_-]{16,128}$/;
 const COLLECTION_ETAG = /^"drive\.permission-collection\.v1\.(0|[1-9][0-9]*)"$/;
 const GRANT_ETAG$1 = /^"drive\.permission-grant\.v1\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"$/;
 const LIST_ETAG$1 = /^"drive\.permission-list\.v1\.[0-9a-f]{64}"$/;
+const ITEM_ETAG = /^"drive\.item\.v1\.(0|[1-9][0-9]*)"$/;
 async function parseResponse(response, operationSignal, preconditionStatus, successStatuses, guard, allowsQuotaExceeded, allowedErrorCodes) {
 	const requestId = safeRequestId(response.headers.get("x-request-id"));
 	if (requestId === null) {
@@ -66,6 +71,24 @@ async function parseResponse(response, operationSignal, preconditionStatus, succ
 		throw new DriveError("invalid_response", { status: response.status });
 	}
 	if (!successStatuses.includes(response.status)) throw await normalizeError(response, requestId, operationSignal, preconditionStatus, allowsQuotaExceeded, allowedErrorCodes);
+	if (response.status === 304) {
+		const contentLength = response.headers.get("content-length");
+		const etag = response.headers.get("etag");
+		const status = response.status;
+		if (response.body !== null || contentLength !== null && contentLength !== "0" || response.headers.has("content-type") || etag === null || !/^"[\x21\x23-\x7e]{1,1022}"$/.test(etag) || !guard(void 0, status, response.headers)) {
+			cancelResponse(response);
+			throw new DriveError("invalid_response", {
+				status,
+				requestId
+			});
+		}
+		return Object.freeze({
+			data: void 0,
+			status,
+			requestId,
+			validators: Object.freeze({ etag })
+		});
+	}
 	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", {
@@ -79,6 +102,28 @@ async function parseResponse(response, operationSignal, preconditionStatus, succ
 		validators: readValidators(response.headers)
 	});
 }
+async function parseNoContentResponse(response, operationSignal, preconditionStatus, successStatuses, allowedErrorCodes) {
+	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, false, allowedErrorCodes);
+	const contentLength = response.headers.get("content-length");
+	if (response.body !== null || contentLength !== null && contentLength !== "0" || response.headers.has("content-type")) {
+		cancelResponse(response);
+		throw new DriveError("invalid_response", {
+			status: response.status,
+			requestId
+		});
+	}
+	return Object.freeze({
+		data: void 0,
+		status: response.status,
+		requestId,
+		validators: Object.freeze({})
+	});
+}
 function parseCollectionEtag(value) {
 	const match = COLLECTION_ETAG.exec(value);
 	if (!match) return void 0;
@@ -92,6 +137,12 @@ function parseGrantEtag(value) {
 	const grantRevision = Number(match[2]);
 	return Number.isSafeInteger(collectionRevision) && Number.isSafeInteger(grantRevision) ? [collectionRevision, grantRevision] : void 0;
 }
+function parseItemEtag(value) {
+	const match = ITEM_ETAG.exec(value);
+	if (!match) return void 0;
+	const revision = Number(match[1]);
+	return Number.isSafeInteger(revision) ? revision : void 0;
+}
 async function normalizeError(response, headerRequestId, signal, preconditionStatus, allowsQuotaExceeded, allowedErrorCodes) {
 	let parsed;
 	try {
@@ -135,8 +186,10 @@ function errorStatusMatches(code, status, preconditionStatus, allowsQuotaExceede
 		invalid_pagination_cursor: [422],
 		invalid_idempotency_key: [422],
 		precondition_failed: preconditionStatus === null ? [] : [preconditionStatus],
+		range_not_satisfiable: [416],
 		idempotency_conflict: [409],
 		quota_exceeded: [409],
+		upload_recovery_required: [409],
 		service_unavailable: [503],
 		internal_error: [500]
 	}[code].includes(status);
@@ -231,7 +284,7 @@ function readValidators(headers) {
 	const permissionCollectionEtag = headers.get("drive-permission-collection-etag");
 	const permissionGrantEtag = headers.get("drive-permission-grant-etag");
 	return Object.freeze({
-		...etag !== null && LIST_ETAG$1.test(etag) ? { etag } : {},
+		...etag !== null && (LIST_ETAG$1.test(etag) || parseItemEtag(etag) !== void 0) ? { etag } : {},
 		...permissionCollectionEtag !== null && parseCollectionEtag(permissionCollectionEtag) !== void 0 ? { permissionCollectionEtag } : {},
 		...permissionGrantEtag !== null && parseGrantEtag(permissionGrantEtag) !== void 0 ? { permissionGrantEtag } : {}
 	});
@@ -247,6 +300,8 @@ const WORKSPACE_ID$1 = /^drive\.workspace\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-
 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$1 = /^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$1 = /^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 VERSION_ID$1 = /^drive\.version\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const RETRIEVAL_ID = /^drive\.retrieval\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const CURSOR$1 = /^drive\.cursor\.v1\.[A-Za-z0-9_-]+$/;
 const AUTH_ID$1 = /^[A-Za-z0-9_-]{1,128}$/;
 const GRANT_ETAG = /^"drive\.permission-grant\.v1\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"$/;
@@ -269,7 +324,9 @@ const EFFECTIVE_ACTIONS = Object.freeze([
 	"items:update"
 ]);
 const MAX_UPLOAD_BYTE_LENGTH$1 = 33554432e4;
-const UPLOAD_QUOTA_EXPIRY_MILLISECONDS = 864e5;
+const UPLOAD_PART_BYTE_LENGTH$2 = 32 * 1024 * 1024;
+const CONTENT_DIGEST$1 = /^sha256:[0-9a-f]{64}$/;
+const UTF8 = new TextEncoder();
 function isCurrentWorkspace(value) {
 	if (!isExactRecord(value, [
 		"workspaceId",
@@ -280,6 +337,61 @@ function isCurrentWorkspace(value) {
 	const reference = value.workspaceReference;
 	return isExactRecord(reference, ["type", "userId"]) && reference.type === "personal" && typeof reference.userId === "string" && AUTH_ID$1.test(reference.userId) || isExactRecord(reference, ["type", "organizationId"]) && reference.type === "organization" && typeof reference.organizationId === "string" && AUTH_ID$1.test(reference.organizationId);
 }
+function isManagedDownloadDescriptor(value) {
+	if (!isExactRecord(value, [
+		"mode",
+		"method",
+		"url",
+		"headers",
+		"expiresAtEpochMilliseconds",
+		"response"
+	]) || value.mode !== "presigned-single" || value.method !== "GET" && value.method !== "HEAD" || typeof value.url !== "string" || !isSafeCapabilityUrl(value.url) || !isSafeInteger$1(value.expiresAtEpochMilliseconds) || !isExactRecord(value.headers, ["if-match"]) && !isExactRecord(value.headers, ["if-match", "range"]) || typeof value.headers["if-match"] !== "string" || !isStrongEtag(value.headers["if-match"]) || value.headers.range !== void 0 && (typeof value.headers.range !== "string" || !/^bytes=(?:0|[1-9][0-9]*)-(?:0|[1-9][0-9]*)$/.test(value.headers.range)) || !isExactRecord(value.response, [
+		"status",
+		"versionId",
+		"byteLength",
+		"contentLength",
+		"contentType",
+		"contentDisposition",
+		"etag",
+		"acceptRanges",
+		"contentRange"
+	]) || value.response.status !== 200 && value.response.status !== 206 || typeof value.response.versionId !== "string" || !VERSION_ID$1.test(value.response.versionId) || !isSafeInteger$1(value.response.byteLength) || !isSafeInteger$1(value.response.contentLength) || typeof value.response.contentType !== "string" || !/^[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?\/[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?$/.test(value.response.contentType) || typeof value.response.contentDisposition !== "string" || value.response.contentDisposition.length > 2048 || !/^[\x20-\x7e]+$/.test(value.response.contentDisposition) || value.response.etag !== value.headers["if-match"] || value.response.acceptRanges !== "bytes" || value.response.contentRange !== null && typeof value.response.contentRange !== "string") return false;
+	if (!downloadDescriptorIsCoherent(value)) return false;
+	Object.freeze(value.headers);
+	Object.freeze(value.response);
+	Object.freeze(value);
+	return true;
+}
+function downloadDescriptorIsCoherent(value) {
+	const response = value.response;
+	if (response.contentLength > response.byteLength || value.method === "HEAD" && response.status !== 200 || !response.contentDisposition.startsWith("attachment; filename=\"")) return false;
+	if (response.status === 200) return value.headers.range === void 0 && response.contentRange === null && response.contentLength === response.byteLength;
+	if (value.method !== "GET" || value.headers.range === void 0 || response.contentRange === null) return false;
+	const range = /^bytes=(0|[1-9][0-9]*)-(0|[1-9][0-9]*)$/.exec(value.headers.range);
+	const contentRange = /^bytes (0|[1-9][0-9]*)-(0|[1-9][0-9]*)\/(0|[1-9][0-9]*)$/.exec(response.contentRange);
+	if (!range || !contentRange) return false;
+	const start = Number(range[1]);
+	const end = Number(range[2]);
+	const contentStart = Number(contentRange[1]);
+	const contentEnd = Number(contentRange[2]);
+	const byteLength = Number(contentRange[3]);
+	return [
+		start,
+		end,
+		contentStart,
+		contentEnd,
+		byteLength
+	].every(isSafeInteger$1) && start === contentStart && end === contentEnd && byteLength === response.byteLength && start <= end && end < byteLength && response.contentLength === end - start + 1;
+}
+function isManagedDownloadRestorePending(value) {
+	return isExactRecord(value, [
+		"mode",
+		"operationId",
+		"versionId",
+		"state",
+		"pollAfterSeconds"
+	]) && value.mode === "restore-pending" && typeof value.operationId === "string" && RETRIEVAL_ID.test(value.operationId) && typeof value.versionId === "string" && VERSION_ID$1.test(value.versionId) && (value.state === "pending" || value.state === "restoring") && isSafeInteger$1(value.pollAfterSeconds) && value.pollAfterSeconds >= 1 && value.pollAfterSeconds <= 60;
+}
 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$1.test(value.nextCursor)))) return false;
 	return value.items.every((item) => item.workspaceId === workspaceId && item.parentItemId === parentItemId) && isStrictlyOrdered(value.items, (item) => item.itemId);
@@ -296,6 +408,101 @@ function isFolderItem(value) {
 		"revision"
 	]) && typeof value.workspaceId === "string" && WORKSPACE_ID$1.test(value.workspaceId) && typeof value.volumeId === "string" && VOLUME_ID.test(value.volumeId) && typeof value.itemId === "string" && ITEM_ID$1.test(value.itemId) && typeof value.parentItemId === "string" && ITEM_ID$1.test(value.parentItemId) && (value.kind === "file" || value.kind === "folder") && isSafeFilename$1(value.name) && (value.visibility === "workspace" || value.visibility === "restricted") && isSafeInteger$1(value.revision);
 }
+function isManagedLifecycleItem(value, workspaceId, itemId, expectedState) {
+	if (!isExactRecord(value, [
+		"workspaceId",
+		"volumeId",
+		"itemId",
+		"parentItemId",
+		"kind",
+		"name",
+		"state",
+		"revision",
+		"purgeAfterEpochMilliseconds"
+	]) || value.workspaceId !== workspaceId || value.itemId !== itemId || typeof value.volumeId !== "string" || !VOLUME_ID.test(value.volumeId) || typeof value.parentItemId !== "string" || !ITEM_ID$1.test(value.parentItemId) || value.kind !== "file" && value.kind !== "folder" || !isSafeFilename$1(value.name) || value.state !== expectedState || !isSafeInteger$1(value.revision) || (value.state === "active" ? value.purgeAfterEpochMilliseconds !== null : !isSafeInteger$1(value.purgeAfterEpochMilliseconds))) return false;
+	Object.freeze(value);
+	return true;
+}
+function isManagedItemMetadata(value, workspaceId, itemId) {
+	if (!isExactRecord(value, [
+		"workspaceId",
+		"itemId",
+		"parentId",
+		"type",
+		"name",
+		"lifecycleState",
+		"revision",
+		"currentVersion"
+	]) || value.workspaceId !== workspaceId || value.itemId !== itemId || !(value.parentId === null || typeof value.parentId === "string" && ITEM_ID$1.test(value.parentId)) || value.type !== "file" && value.type !== "folder" || !isSafeFilename$1(value.name) || value.lifecycleState !== "active" || !isSafeInteger$1(value.revision) || (value.type === "folder" ? value.currentVersion !== null : !isCurrentVersionMetadata(value.currentVersion))) return false;
+	if (value.currentVersion !== null) Object.freeze(value.currentVersion);
+	Object.freeze(value);
+	return true;
+}
+function isWorkspaceItemSearchPage(value, workspaceId, query, limit) {
+	if (!isExactRecord(value, ["items", "nextCursor"]) || !Array.isArray(value.items) || value.items.length > limit || !value.items.every((item) => isWorkspaceItemSearchItem(item, workspaceId, query)) || !(value.nextCursor === null || typeof value.nextCursor === "string" && value.nextCursor.length <= 699 && CURSOR$1.test(value.nextCursor)) || value.items.length === 0 && value.nextCursor !== null || new Set(value.items.map((item) => item.itemId)).size !== value.items.length || !isWorkspaceItemSearchOrder(value.items)) return false;
+	for (const item of value.items) {
+		if (item.currentVersion !== null) Object.freeze(item.currentVersion);
+		Object.freeze(item);
+	}
+	Object.freeze(value.items);
+	Object.freeze(value);
+	return true;
+}
+function itemEtagMatchesRevision(headers, revision) {
+	const etag = headers.get("etag");
+	return etag !== null && parseItemEtag(etag) === revision;
+}
+function isCurrentVersionMetadata(value) {
+	return isExactRecord(value, [
+		"versionId",
+		"state",
+		"byteLength",
+		"mediaType",
+		"protectionClassification"
+	]) && typeof value.versionId === "string" && VERSION_ID$1.test(value.versionId) && value.state === "current" && isSafeInteger$1(value.byteLength) && isMediaType$1(value.mediaType) && (value.protectionClassification === "ordinary" || value.protectionClassification === "opaque-encrypted");
+}
+function isWorkspaceItemSearchItem(value, workspaceId, query) {
+	return isExactRecord(value, [
+		"workspaceId",
+		"volumeId",
+		"provider",
+		"itemId",
+		"parentId",
+		"type",
+		"name",
+		"lifecycleState",
+		"revision",
+		"currentVersion"
+	]) && value.workspaceId === workspaceId && typeof value.volumeId === "string" && VOLUME_ID.test(value.volumeId) && value.provider === "managed" && typeof value.itemId === "string" && ITEM_ID$1.test(value.itemId) && (value.parentId === null || typeof value.parentId === "string" && ITEM_ID$1.test(value.parentId)) && (value.type === "file" || value.type === "folder") && isSafeFilename$1(value.name) && value.name.startsWith(query) && value.lifecycleState === "active" && isSafeInteger$1(value.revision) && (value.type === "folder" ? value.currentVersion === null : isCurrentVersionMetadata(value.currentVersion));
+}
+function isWorkspaceItemSearchOrder(items) {
+	for (let index = 1; index < items.length; index += 1) {
+		const previous = items[index - 1];
+		const current = items[index];
+		const nameOrder = compareBinary(previous.name, current.name);
+		if (nameOrder > 0 || nameOrder === 0 && previous.itemId >= current.itemId) return false;
+	}
+	return true;
+}
+function compareBinary(left, right) {
+	const leftBytes = UTF8.encode(left);
+	const rightBytes = UTF8.encode(right);
+	const length = Math.min(leftBytes.length, rightBytes.length);
+	for (let index = 0; index < length; index += 1) if (leftBytes[index] !== rightBytes[index]) return leftBytes[index] - rightBytes[index];
+	return leftBytes.length - rightBytes.length;
+}
+function isManagedItemVersionPage(value, limit) {
+	if (!isExactRecord(value, ["items", "nextCursor"]) || !Array.isArray(value.items) || value.items.length > limit || !value.items.every(isManagedItemVersion) || !(value.nextCursor === null || typeof value.nextCursor === "string" && value.nextCursor.length <= 699 && CURSOR$1.test(value.nextCursor)) || value.nextCursor !== null && value.items.length === 0 || !isStrictlyOrdered(value.items, (version) => version.versionId)) return false;
+	for (const version of value.items) Object.freeze(version);
+	Object.freeze(value.items);
+	Object.freeze(value);
+	return true;
+}
+function isManagedItemVersionRestoreResult(value, versionId) {
+	if (!isExactRecord(value, ["itemRevision", "currentVersionId"]) || !isSafeInteger$1(value.itemRevision) || value.currentVersionId !== versionId) return false;
+	Object.freeze(value);
+	return true;
+}
 function isPermissionPage(value, headers, targetItemId) {
 	if (!(isExactRecord(value, [
 		"items",
@@ -350,18 +557,127 @@ function isEffectivePermissionResponse(value, targetItemId) {
 	}
 	return true;
 }
-function isUploadQuotaReservation(value) {
-	return isExactRecord(value, [
-		"workspaceId",
+function isUploadSession(value, expectedByteLength) {
+	if (!isExactRecord(value, [
+		"itemId",
+		"versionId",
 		"uploadId",
-		"parentItemId",
-		"expectedByteLength",
-		"state",
-		"terminalReason",
-		"createdAtEpochMilliseconds",
+		"mode",
+		"partByteLength",
+		"partCount",
+		"revision",
+		"expiresAtEpochMilliseconds"
+	]) || typeof value.itemId !== "string" || !ITEM_ID$1.test(value.itemId) || typeof value.versionId !== "string" || !VERSION_ID$1.test(value.versionId) || typeof value.uploadId !== "string" || !UPLOAD_ID$1.test(value.uploadId) || value.mode !== "presigned-multipart" && value.mode !== "server-mediated-zero-byte" || value.partByteLength !== UPLOAD_PART_BYTE_LENGTH$2 || !isSafeInteger$1(value.partCount) || value.partCount > 1e4 || value.partCount !== Math.ceil(expectedByteLength / UPLOAD_PART_BYTE_LENGTH$2) || (expectedByteLength === 0 ? value.mode !== "server-mediated-zero-byte" : value.mode !== "presigned-multipart") || !isSafeInteger$1(value.revision) || !isSafeInteger$1(value.expiresAtEpochMilliseconds) || value.expiresAtEpochMilliseconds <= Date.now()) return false;
+	Object.freeze(value);
+	return true;
+}
+function isUploadStatus(value, afterPartNumber, limit) {
+	if (!isExactRecord(value, [
+		"itemId",
+		"versionId",
+		"uploadId",
+		"mode",
+		"lifecycle",
+		"revision",
+		"partPolicy",
+		"confirmedParts",
+		"nextAfterPartNumber",
 		"expiresAtEpochMilliseconds",
-		"terminalAtEpochMilliseconds"
-	]) && typeof value.workspaceId === "string" && WORKSPACE_ID$1.test(value.workspaceId) && typeof value.uploadId === "string" && UPLOAD_ID$1.test(value.uploadId) && typeof value.parentItemId === "string" && ITEM_ID$1.test(value.parentItemId) && typeof value.expectedByteLength === "number" && Number.isSafeInteger(value.expectedByteLength) && value.expectedByteLength >= 0 && value.expectedByteLength <= MAX_UPLOAD_BYTE_LENGTH$1 && (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$1(value.createdAtEpochMilliseconds) && isSafeInteger$1(value.expiresAtEpochMilliseconds) && value.expiresAtEpochMilliseconds - value.createdAtEpochMilliseconds === UPLOAD_QUOTA_EXPIRY_MILLISECONDS && (value.terminalAtEpochMilliseconds === null || isSafeInteger$1(value.terminalAtEpochMilliseconds) && value.terminalAtEpochMilliseconds >= value.createdAtEpochMilliseconds);
+		"ready"
+	]) || typeof value.itemId !== "string" || !ITEM_ID$1.test(value.itemId) || typeof value.versionId !== "string" || !VERSION_ID$1.test(value.versionId) || typeof value.uploadId !== "string" || !UPLOAD_ID$1.test(value.uploadId) || value.mode !== "presigned-multipart" && value.mode !== "server-mediated-zero-byte" || ![
+		"initiating",
+		"recovery-required",
+		"uploading",
+		"completing",
+		"provider-completed",
+		"ready",
+		"aborting",
+		"aborted"
+	].includes(String(value.lifecycle)) || !isSafeInteger$1(value.revision) || !isExactRecord(value.partPolicy, [
+		"partByteLength",
+		"partCount",
+		"maxParts"
+	]) || value.partPolicy.partByteLength !== UPLOAD_PART_BYTE_LENGTH$2 || !isSafeInteger$1(value.partPolicy.partCount) || value.partPolicy.partCount > 1e4 || value.partPolicy.maxParts !== 1e4 || (value.mode === "server-mediated-zero-byte" ? value.partPolicy.partCount !== 0 : value.partPolicy.partCount < 1) || !Array.isArray(value.confirmedParts) || value.confirmedParts.length > limit || !isSafeInteger$1(value.expiresAtEpochMilliseconds)) return false;
+	let previousPartNumber = afterPartNumber;
+	for (const part of value.confirmedParts) {
+		if (!isExactRecord(part, ["partNumber", "checksumSha256"]) || !isSafeInteger$1(part.partNumber) || part.partNumber <= previousPartNumber || part.partNumber > value.partPolicy.partCount || !isPartChecksum$1(part.checksumSha256)) return false;
+		previousPartNumber = part.partNumber;
+	}
+	if (!(value.nextAfterPartNumber === null || isSafeInteger$1(value.nextAfterPartNumber) && value.confirmedParts.length === limit && value.nextAfterPartNumber === previousPartNumber) || value.mode === "server-mediated-zero-byte" && (value.confirmedParts.length !== 0 || value.nextAfterPartNumber !== null) || value.lifecycle === "ready" !== (value.ready !== null) || value.ready !== null && (!isReadyUpload(value.ready, { uploadId: value.uploadId }) || value.ready.itemId !== value.itemId || value.ready.versionId !== value.versionId)) return false;
+	Object.freeze(value.partPolicy);
+	for (const part of value.confirmedParts) Object.freeze(part);
+	Object.freeze(value.confirmedParts);
+	Object.freeze(value);
+	return true;
+}
+function isUploadPartDescriptor(value, expectedPartNumber, checksumSha256, allowInsecureHttp) {
+	if (!isExactRecord(value, [
+		"url",
+		"method",
+		"headers",
+		"partNumber",
+		"expectedByteLength",
+		"expiresAtEpochMilliseconds"
+	]) || !isSignedTransferUrl(value.url, allowInsecureHttp) || value.method !== "PUT" || !isExactRecord(value.headers, ["x-amz-checksum-sha256"]) || value.headers["x-amz-checksum-sha256"] !== checksumSha256 || value.partNumber !== expectedPartNumber || !isSafeInteger$1(value.expectedByteLength) || value.expectedByteLength < 1 || value.expectedByteLength > UPLOAD_PART_BYTE_LENGTH$2 || !isSafeInteger$1(value.expiresAtEpochMilliseconds) || value.expiresAtEpochMilliseconds <= Date.now()) return false;
+	Object.freeze(value.headers);
+	Object.freeze(value);
+	return true;
+}
+function isUploadPartResult(value, expectedPartNumber, expectedUploadRevision) {
+	if (!isExactRecord(value, ["partNumber", "revision"]) || value.partNumber !== expectedPartNumber || value.revision !== expectedUploadRevision + 1 || !isSafeInteger$1(value.revision)) return false;
+	Object.freeze(value);
+	return true;
+}
+function isReadyUpload(value, expected) {
+	if (!isExactRecord(value, [
+		"itemId",
+		"versionId",
+		"uploadId",
+		"byteLength",
+		"callerDeclaredContentDigest",
+		"displayFilename",
+		"mediaType",
+		"state"
+	]) || typeof value.itemId !== "string" || !ITEM_ID$1.test(value.itemId) || typeof value.versionId !== "string" || !VERSION_ID$1.test(value.versionId) || value.uploadId !== expected.uploadId || !isSafeInteger$1(value.byteLength) || value.byteLength < 0 || value.byteLength > MAX_UPLOAD_BYTE_LENGTH$1 || typeof value.callerDeclaredContentDigest !== "string" || !CONTENT_DIGEST$1.test(value.callerDeclaredContentDigest) || !isSafeFilename$1(value.displayFilename) || !isMediaType$1(value.mediaType) || value.state !== "ready" || expected.byteLength !== void 0 && value.byteLength !== expected.byteLength || expected.callerDeclaredContentDigest !== void 0 && value.callerDeclaredContentDigest !== expected.callerDeclaredContentDigest || expected.displayFilename !== void 0 && value.displayFilename !== expected.displayFilename || expected.mediaType !== void 0 && value.mediaType !== expected.mediaType) return false;
+	Object.freeze(value);
+	return true;
+}
+function isPartChecksum$1(value) {
+	return typeof value === "string" && /^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw048]=$/.test(value);
+}
+function isManagedItemVersion(value) {
+	const valid = isExactRecord(value, managedItemVersionKeys) && managedItemVersionFieldsAreValid(value);
+	if (valid) Object.freeze(value);
+	return valid;
+}
+function isManagedItemVersionResource(value, workspaceId, itemId, versionId) {
+	const valid = isExactRecord(value, [
+		...managedItemVersionKeys,
+		"workspaceId",
+		"itemId"
+	]) && value.workspaceId === workspaceId && value.itemId === itemId && value.versionId === versionId && managedItemVersionFieldsAreValid(value);
+	if (valid) Object.freeze(value);
+	return valid;
+}
+const managedItemVersionKeys = Object.freeze([
+	"versionId",
+	"state",
+	"revision",
+	"byteLength",
+	"contentDigest",
+	"mediaType",
+	"displayFilename",
+	"protectionClassification",
+	"archiveState"
+]);
+function managedItemVersionFieldsAreValid(value) {
+	return typeof value.versionId === "string" && VERSION_ID$1.test(value.versionId) && (value.state === "current" || value.state === "superseded") && isSafeInteger$1(value.revision) && isSafeInteger$1(value.byteLength) && typeof value.contentDigest === "string" && CONTENT_DIGEST$1.test(value.contentDigest) && isMediaType$1(value.mediaType) && isSafeFilename$1(value.displayFilename) && (value.protectionClassification === "ordinary" || value.protectionClassification === "opaque-encrypted") && [
+		"available",
+		"cold",
+		"restoring",
+		"unavailable",
+		"corrupt"
+	].includes(String(value.archiveState));
 }
 function mutationValidatorsAreCoherent(headers) {
 	const collection = headers.get("drive-permission-collection-etag");
@@ -418,6 +734,19 @@ function isSafeFilename$1(value) {
 	}
 	return true;
 }
+function isMediaType$1(value) {
+	return typeof value === "string" && value.length <= 255 && /^[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?\/[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?$/.test(value);
+}
+function isSignedTransferUrl(value, allowInsecureHttp) {
+	if (typeof value !== "string" || value.length < 1 || value.length > 8192 || value !== value.trim()) return false;
+	try {
+		const url = new URL(value);
+		const loopbackHost = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+		return (url.protocol === "https:" || url.protocol === "http:" && allowInsecureHttp && loopbackHost) && url.username === "" && url.password === "" && url.hash === "" && url.host !== "";
+	} catch {
+		return false;
+	}
+}
 function filenameIsReserved$1(value) {
 	const base = value.split(".", 1)[0].toUpperCase();
 	return value === "." || value === ".." || [
@@ -436,6 +765,22 @@ function isStrictlyOrdered(values, key) {
 function isSafeInteger$1(value) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
+function isStrongEtag(value) {
+	return /^"[\x21\x23-\x7e]{1,1022}"$/.test(value);
+}
+function isSafeCapabilityUrl(value) {
+	try {
+		const url = new URL(value);
+		const localHttp = url.protocol === "http:" && [
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname);
+		return (url.protocol === "https:" || localHttp) && !url.username && !url.password && !url.hash;
+	} catch {
+		return false;
+	}
+}
 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));
@@ -446,6 +791,7 @@ const ITEM_ID = /^drive\.item\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-
 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 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 VERSION_ID = /^drive\.version\.[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([
@@ -457,7 +803,10 @@ const PERMISSION_ACTIONS = Object.freeze([
 	"items:update"
 ]);
 const IDEMPOTENCY_KEY = /^[A-Za-z0-9_-]{16,128}$/;
+const CONTENT_DIGEST = /^sha256:[0-9a-f]{64}$/;
+const PART_CHECKSUM = /^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw048]=$/;
 const MAX_UPLOAD_BYTE_LENGTH = 33554432e4;
+const UPLOAD_PART_BYTE_LENGTH$1 = 32 * 1024 * 1024;
 function validateCurrentWorkspaceInput(value) {
 	const signal = validateSignal(captureRecord(value === void 0 ? {} : value, [], ["signal"]).signal);
 	return signal === void 0 ? {} : { signal };
@@ -474,6 +823,71 @@ function validateResourceInput(value) {
 		...signal === void 0 ? {} : { signal }
 	};
 }
+function validateItemVersionInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"versionId"
+	], ["signal"]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	if (typeof input.versionId !== "string" || !VERSION_ID.test(input.versionId)) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		versionId: input.versionId
+	};
+}
+function validateCreateDownloadInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"idempotencyKey"
+	], [
+		"versionId",
+		"method",
+		"range",
+		"ifMatch",
+		"ifNoneMatch",
+		"ifRange",
+		"signal"
+	]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	const method = input.method ?? "GET";
+	if (!isIdempotencyKey(input.idempotencyKey) || input.versionId !== void 0 && (typeof input.versionId !== "string" || !VERSION_ID.test(input.versionId)) || method !== "GET" && method !== "HEAD" || input.range !== void 0 && (typeof input.range !== "string" || input.range.length > 128 || !/^bytes=(?:[0-9]+-[0-9]*|-[0-9]+)$/.test(input.range)) || !isOptionalHeaderValue(input.ifMatch) || !isOptionalHeaderValue(input.ifNoneMatch) || !isOptionalHeaderValue(input.ifRange)) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		idempotencyKey: input.idempotencyKey,
+		method,
+		...input.versionId === void 0 ? {} : { versionId: input.versionId },
+		...input.range === void 0 ? {} : { range: input.range },
+		...input.ifMatch === void 0 ? {} : { ifMatch: input.ifMatch },
+		...input.ifNoneMatch === void 0 ? {} : { ifNoneMatch: input.ifNoneMatch },
+		...input.ifRange === void 0 ? {} : { ifRange: input.ifRange }
+	};
+}
+function validateSearchWorkspaceItemsInput(value) {
+	const input = captureRecord(value, ["workspaceId", "query"], [
+		"limit",
+		"cursor",
+		"signal"
+	]);
+	const signal = validateSignal(input.signal);
+	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || !isSearchQuery(input.query) || input.limit !== void 0 && (!isSafeInteger(input.limit) || input.limit < 1 || input.limit > 50) || input.cursor !== void 0 && (typeof input.cursor !== "string" || input.cursor.length > 699 || !CURSOR.test(input.cursor))) throw new DriveError("invalid_input");
+	return {
+		workspaceId: input.workspaceId,
+		query: input.query,
+		...input.limit === void 0 ? {} : { limit: input.limit },
+		...input.cursor === void 0 ? {} : { cursor: input.cursor },
+		...signal === void 0 ? {} : { signal }
+	};
+}
 function validatePageInput(value) {
 	const input = captureRecord(value, ["workspaceId", "itemId"], [
 		"signal",
@@ -513,6 +927,69 @@ function validateCreateFolderInput(value) {
 		idempotencyKey: input.idempotencyKey
 	};
 }
+function validateUpdateItemInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"name",
+		"parentItemId",
+		"idempotencyKey",
+		"ifMatch"
+	], ["signal"]);
+	const mutation = validateLifecycleMutationInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		idempotencyKey: input.idempotencyKey,
+		ifMatch: input.ifMatch,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	if (!isSafeFilename(input.name) || typeof input.parentItemId !== "string" || !ITEM_ID.test(input.parentItemId)) throw new DriveError("invalid_input");
+	return {
+		...mutation,
+		name: input.name,
+		parentItemId: input.parentItemId
+	};
+}
+function validateLifecycleMutationInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"idempotencyKey",
+		"ifMatch"
+	], ["signal"]);
+	const resource = validateResourceInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	if (!isIdempotencyKey(input.idempotencyKey) || typeof input.ifMatch !== "string" || parseItemEtag(input.ifMatch) === void 0) throw new DriveError("invalid_input");
+	return {
+		...resource,
+		idempotencyKey: input.idempotencyKey,
+		ifMatch: input.ifMatch
+	};
+}
+function validateRestoreItemVersionInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"itemId",
+		"versionId",
+		"idempotencyKey",
+		"ifMatch"
+	], ["signal"]);
+	const mutation = validateLifecycleMutationInput({
+		workspaceId: input.workspaceId,
+		itemId: input.itemId,
+		idempotencyKey: input.idempotencyKey,
+		ifMatch: input.ifMatch,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	if (typeof input.versionId !== "string" || !VERSION_ID.test(input.versionId)) throw new DriveError("invalid_input");
+	return {
+		...mutation,
+		versionId: input.versionId
+	};
+}
 function validateCreatePermissionInput(value) {
 	const input = captureRecord(value, [
 		"workspaceId",
@@ -596,26 +1073,133 @@ function validateCreateUploadInput(value) {
 		"workspaceId",
 		"parentItemId",
 		"expectedByteLength",
+		"displayFilename",
+		"mediaType",
+		"callerDeclaredContentDigest",
+		"protectionClassification",
 		"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");
+	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 || !isSafeFilename(input.displayFilename) || !isMediaType(input.mediaType) || typeof input.callerDeclaredContentDigest !== "string" || !CONTENT_DIGEST.test(input.callerDeclaredContentDigest) || input.protectionClassification !== "ordinary" && input.protectionClassification !== "opaque-encrypted" || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
 	return {
 		workspaceId: input.workspaceId,
 		parentItemId: input.parentItemId,
 		expectedByteLength: input.expectedByteLength,
+		displayFilename: input.displayFilename,
+		mediaType: input.mediaType,
+		callerDeclaredContentDigest: input.callerDeclaredContentDigest,
+		protectionClassification: input.protectionClassification,
 		idempotencyKey: input.idempotencyKey,
 		...signal === void 0 ? {} : { signal }
 	};
 }
+function validateGetUploadStatusInput(value) {
+	const input = captureRecord(value, ["workspaceId", "uploadId"], [
+		"afterPartNumber",
+		"limit",
+		"signal"
+	]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (input.afterPartNumber !== void 0 && (!isSafeInteger(input.afterPartNumber) || input.afterPartNumber > 1e4) || input.limit !== void 0 && (!isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		...input.afterPartNumber === void 0 ? {} : { afterPartNumber: input.afterPartNumber },
+		...input.limit === void 0 ? {} : { limit: input.limit }
+	};
+}
+function validateCreateUploadPartDescriptorInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"partNumber",
+		"checksumSha256"
+	], ["signal"]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (!isPartNumber(input.partNumber) || !isPartChecksum(input.checksumSha256)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		partNumber: input.partNumber,
+		checksumSha256: input.checksumSha256
+	};
+}
+function validateRecordUploadPartInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"partNumber",
+		"expectedUploadRevision",
+		"byteLength",
+		"etag",
+		"checksumSha256"
+	], ["signal"]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (!isPartNumber(input.partNumber) || !isSafeInteger(input.expectedUploadRevision) || input.expectedUploadRevision >= Number.MAX_SAFE_INTEGER || !isSafeInteger(input.byteLength) || input.byteLength < 1 || input.byteLength > UPLOAD_PART_BYTE_LENGTH$1 || !isEtag$1(input.etag) || !isPartChecksum(input.checksumSha256)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		partNumber: input.partNumber,
+		expectedUploadRevision: input.expectedUploadRevision,
+		byteLength: input.byteLength,
+		etag: input.etag,
+		checksumSha256: input.checksumSha256
+	};
+}
+function validateCompleteUploadInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"idempotencyKey"
+	], ["signal"]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (!isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		idempotencyKey: input.idempotencyKey
+	};
+}
 function validateAbortUploadInput(value) {
 	const input = captureRecord(value, ["workspaceId", "uploadId"], ["signal"]);
+	return validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+}
+function validateUploadFileInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"parentItemId",
+		"source",
+		"displayFilename",
+		"idempotencyKey",
+		"completionIdempotencyKey"
+	], [
+		"mediaType",
+		"protectionClassification",
+		"signal",
+		"onProgress"
+	]);
 	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");
+	const mediaType = input.mediaType ?? "application/octet-stream";
+	const protectionClassification = input.protectionClassification ?? "ordinary";
+	let source;
+	let byteLength;
+	try {
+		if (!(input.source instanceof Blob)) throw new DriveError("invalid_input");
+		source = input.source;
+		byteLength = source.size;
+	} catch (error) {
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("invalid_input");
+	}
+	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.parentItemId !== "string" || !ITEM_ID.test(input.parentItemId) || !Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > MAX_UPLOAD_BYTE_LENGTH || !isSafeFilename(input.displayFilename) || !isMediaType(mediaType) || protectionClassification !== "ordinary" && protectionClassification !== "opaque-encrypted" || !isIdempotencyKey(input.idempotencyKey) || !isIdempotencyKey(input.completionIdempotencyKey) || input.onProgress !== void 0 && typeof input.onProgress !== "function") throw new DriveError("invalid_input");
 	return {
 		workspaceId: input.workspaceId,
-		uploadId: input.uploadId,
-		...signal === void 0 ? {} : { signal }
+		parentItemId: input.parentItemId,
+		source,
+		byteLength,
+		displayFilename: input.displayFilename,
+		mediaType,
+		protectionClassification,
+		idempotencyKey: input.idempotencyKey,
+		completionIdempotencyKey: input.completionIdempotencyKey,
+		...signal === void 0 ? {} : { signal },
+		...input.onProgress === void 0 ? {} : { onProgress: input.onProgress }
 	};
 }
 function resourcePath(input) {
@@ -702,12 +1286,51 @@ function captureArray(value) {
 function isIdempotencyKey(value) {
 	return typeof value === "string" && IDEMPOTENCY_KEY.test(value);
 }
-function isExpiry(value) {
-	return value === null || isSafeInteger(value);
+function validateUploadPath(workspaceId, uploadId, signalValue) {
+	const signal = validateSignal(signalValue);
+	if (typeof workspaceId !== "string" || !WORKSPACE_ID.test(workspaceId) || typeof uploadId !== "string" || !UPLOAD_ID.test(uploadId)) throw new DriveError("invalid_input");
+	return {
+		workspaceId,
+		uploadId,
+		...signal === void 0 ? {} : { signal }
+	};
 }
-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;
+function isPartNumber(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 1e4;
+}
+function isPartChecksum(value) {
+	return typeof value === "string" && PART_CHECKSUM.test(value);
+}
+function isEtag$1(value) {
+	return typeof value === "string" && value.length >= 1 && value.length <= 1024 && /^[\x20-\x7e]+$/.test(value);
+}
+function isMediaType(value) {
+	return typeof value === "string" && value.length <= 255 && /^[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?\/[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?$/.test(value);
+}
+function isSearchQuery(value) {
+	if (typeof value !== "string" || value.length === 0) return false;
+	try {
+		if (value.normalize("NFC") !== value) return false;
+		let codePoints = 0;
+		let bytes = 0;
+		for (const character of value) {
+			const point = character.codePointAt(0);
+			if (point === void 0 || 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 > 64 || bytes > 255) return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isExpiry(value) {
+	return value === null || isSafeInteger(value);
+}
+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);
@@ -733,6 +1356,12 @@ function filenameIsReserved(value) {
 function isSafeInteger(value) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
+function isOptionalHeaderValue(value) {
+	return value === void 0 || typeof value === "string" && value.length <= 8192 && !value.split("").some((character) => {
+		const code = character.charCodeAt(0);
+		return code <= 31 || code === 127;
+	});
+}
 //#endregion
 //#region ../../node_modules/.pnpm/openapi-fetch@0.17.0/node_modules/openapi-fetch/dist/index.mjs
 const PATH_PARAM_RE = /\{[^{}]+\}/g;
@@ -1188,7 +1817,7 @@ async function execute(runtime, signal, preconditionStatus, send, successStatuse
 			signal: operationSignal
 		});
 		if (!capturedResponse) throw new DriveError("network_error");
-		return await parseResponse(capturedResponse, operationSignal, preconditionStatus, successStatuses, guard, allowsQuotaExceeded, allowedErrorCodes);
+		return guard === null ? await parseNoContentResponse(capturedResponse, operationSignal, preconditionStatus, successStatuses, allowedErrorCodes) : await parseResponse(capturedResponse, operationSignal, preconditionStatus, successStatuses, guard, allowsQuotaExceeded, allowedErrorCodes);
 	} catch (error) {
 		if (operation.didTimeout()) throw new DriveError("timeout");
 		if (error instanceof DriveError) throw error;
@@ -1276,27 +1905,310 @@ const CURRENT_WORKSPACE_ERROR_CODES = Object.freeze([
 	"invalid_request",
 	"service_unavailable"
 ]);
-function createDriveClientInternal(config) {
-	const runtime = createClientRuntime(config);
+const GET_ITEM_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"precondition_failed",
+	"service_unavailable"
+]);
+const SEARCH_WORKSPACE_ITEMS_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"invalid_pagination_cursor",
+	"precondition_failed",
+	"service_unavailable"
+]);
+const TRANSFER_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"precondition_failed",
+	"upload_recovery_required",
+	"service_unavailable"
+]);
+const STATUS_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"service_unavailable"
+]);
+const CREATE_UPLOAD_ERROR_CODES = Object.freeze([
+	...TRANSFER_ERROR_CODES,
+	"invalid_idempotency_key",
+	"idempotency_conflict",
+	"quota_exceeded"
+]);
+const COMPLETE_UPLOAD_ERROR_CODES = Object.freeze([...TRANSFER_ERROR_CODES, "invalid_idempotency_key"]);
+const LIFECYCLE_MUTATION_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"invalid_idempotency_key",
+	"idempotency_conflict",
+	"precondition_failed",
+	"service_unavailable"
+]);
+const LIST_ITEM_VERSIONS_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"precondition_failed",
+	"service_unavailable"
+]);
+const DOWNLOAD_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"invalid_idempotency_key",
+	"idempotency_conflict",
+	"precondition_failed",
+	"range_not_satisfiable",
+	"service_unavailable"
+]);
+function createDriveOperations(runtime) {
 	return Object.freeze({
 		getCurrentWorkspace: (input) => getCurrentWorkspace(runtime, input),
+		getItem: (input) => getItem(runtime, input),
+		searchWorkspaceItems: (input) => searchWorkspaceItems(runtime, input),
 		listFolderChildren: (input) => listFolderChildren(runtime, input),
 		createFolder: (input) => createFolder(runtime, input),
+		updateItem: (input) => updateItem(runtime, input),
+		trashItem: (input) => trashItem(runtime, input),
+		restoreItem: (input) => restoreItem(runtime, input),
+		deleteItem: (input) => deleteItem(runtime, input),
+		listItemVersions: (input) => listItemVersions(runtime, input),
+		getItemVersion: (input) => getItemVersion(runtime, input),
+		restoreItemVersion: (input) => restoreItemVersion(runtime, input),
+		createDownload: (input) => createDownload(runtime, input),
+		downloadItem: (input) => downloadItem(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),
+		getUploadStatus: (input) => getUploadStatus(runtime, input),
+		createUploadPartDescriptor: (input) => createUploadPartDescriptor(runtime, input),
+		recordUploadPart: (input) => recordUploadPart(runtime, input),
+		completeUpload: (input) => completeUpload(runtime, input),
 		abortUpload: (input) => abortUpload(runtime, input)
 	});
 }
+async function createDownload(runtime, input) {
+	const validated = validateCreateDownloadInput(input);
+	return execute(runtime, validated.signal, 412, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/items/{itemId}/downloads", {
+		...operationOptions("createDownload", { params: {
+			path: {
+				workspaceId: validated.workspaceId,
+				itemId: validated.itemId
+			},
+			query: validated.versionId === void 0 ? {} : { versionId: validated.versionId },
+			header: {
+				"Idempotency-Key": validated.idempotencyKey,
+				"Download-Method": validated.method,
+				...validated.range === void 0 ? {} : { Range: validated.range },
+				...validated.ifMatch === void 0 ? {} : { "If-Match": validated.ifMatch },
+				...validated.ifNoneMatch === void 0 ? {} : { "If-None-Match": validated.ifNoneMatch },
+				...validated.ifRange === void 0 ? {} : { "If-Range": validated.ifRange }
+			}
+		} }),
+		...requestOptions
+	}), [
+		200,
+		202,
+		304
+	], (value, status) => status === 200 ? isManagedDownloadDescriptor(value) : status === 202 ? isManagedDownloadRestorePending(value) : value === void 0, false, DOWNLOAD_ERROR_CODES);
+}
+async function downloadItem(runtime, input) {
+	const validated = validateCreateDownloadInput(input);
+	const created = await createDownload(runtime, input);
+	if (created.status === 202 || created.status === 304) return created;
+	const descriptor = created.data;
+	if (descriptor.expiresAtEpochMilliseconds <= Date.now()) throw new DriveError("invalid_response");
+	const operation = createOperationSignal(validated.signal, runtime.timeoutMilliseconds);
+	try {
+		const response = await raceWithAbort(runtime.fetchImplementation(directDownloadRequest(descriptor, operation.signal)), operation.signal);
+		if (!responseMatchesDownloadDescriptor(response, descriptor)) {
+			await response.body?.cancel().catch(() => void 0);
+			throw new DriveError("invalid_response");
+		}
+		const responseHeaders = downloadResponseHeaders(descriptor);
+		if (descriptor.method === "HEAD") {
+			await response.body?.cancel().catch(() => void 0);
+			operation.dispose();
+			return new Response(null, {
+				status: response.status,
+				headers: responseHeaders
+			});
+		}
+		if (!response.body) {
+			operation.dispose();
+			if (descriptor.response.contentLength !== 0) throw new DriveError("invalid_response");
+			return new Response(null, {
+				status: response.status,
+				headers: responseHeaders
+			});
+		}
+		operation.dispose();
+		return new Response(streamWithOperationLifetime(response.body, descriptor.response.contentLength, validated.signal), {
+			status: response.status,
+			headers: responseHeaders
+		});
+	} catch (error) {
+		operation.dispose();
+		if (operation.didTimeout()) throw new DriveError("timeout");
+		if (error instanceof DriveError) throw error;
+		throw operation.signal.aborted ? new DriveError(operation.didTimeout() ? "timeout" : "aborted") : new DriveError("network_error");
+	}
+}
+function downloadResponseHeaders(descriptor) {
+	const expected = descriptor.response;
+	const headers = new Headers();
+	headers.set("accept-ranges", expected.acceptRanges);
+	headers.set("content-disposition", expected.contentDisposition);
+	headers.set("content-length", String(expected.contentLength));
+	headers.set("content-type", expected.contentType);
+	headers.set("etag", expected.etag);
+	if (expected.contentRange === null) headers.delete("content-range");
+	else headers.set("content-range", expected.contentRange);
+	return headers;
+}
+function directDownloadRequest(descriptor, signal) {
+	const base = {
+		method: descriptor.method,
+		headers: descriptor.headers,
+		redirect: "manual",
+		signal
+	};
+	try {
+		return new Request(descriptor.url, {
+			...base,
+			cache: "no-store",
+			credentials: "omit",
+			referrerPolicy: "no-referrer"
+		});
+	} catch {
+		try {
+			return new Request(descriptor.url, {
+				...base,
+				credentials: "omit",
+				referrerPolicy: "no-referrer"
+			});
+		} catch {
+			return new Request(descriptor.url, {
+				...base,
+				credentials: "omit"
+			});
+		}
+	}
+}
+function responseMatchesDownloadDescriptor(response, descriptor) {
+	const expected = descriptor.response;
+	const encoding = response.headers.get("content-encoding");
+	return response.status === expected.status && response.headers.get("etag") === expected.etag && response.headers.get("content-length") === String(expected.contentLength) && (encoding === null || encoding === "identity") && (expected.contentRange === null ? response.headers.get("content-range") === null : response.headers.get("content-range") === expected.contentRange);
+}
+function streamWithOperationLifetime(source, expectedLength, signal) {
+	const reader = source.getReader();
+	let receivedLength = 0;
+	let finished = false;
+	let removeAbort = () => {};
+	return new ReadableStream({
+		start(controller) {
+			if (!signal) return;
+			const onAbort = () => {
+				if (finished) return;
+				finished = true;
+				removeAbort();
+				reader.cancel().catch(() => void 0);
+				controller.error(new DriveError("aborted"));
+			};
+			if (signal.aborted) onAbort();
+			else {
+				signal.addEventListener("abort", onAbort, { once: true });
+				removeAbort = () => signal.removeEventListener("abort", onAbort);
+			}
+		},
+		async pull(controller) {
+			if (finished) return;
+			try {
+				const chunk = await reader.read();
+				if (finished) return;
+				if (chunk.done) {
+					finished = true;
+					removeAbort();
+					reader.releaseLock();
+					if (receivedLength === expectedLength) controller.close();
+					else controller.error(new DriveError("invalid_response"));
+				} else {
+					receivedLength += chunk.value.byteLength;
+					if (!Number.isSafeInteger(receivedLength) || receivedLength > expectedLength) {
+						finished = true;
+						removeAbort();
+						await reader.cancel().catch(() => void 0);
+						controller.error(new DriveError("invalid_response"));
+						return;
+					}
+					controller.enqueue(chunk.value);
+				}
+			} catch (error) {
+				if (finished) return;
+				finished = true;
+				removeAbort();
+				await reader.cancel().catch(() => void 0);
+				controller.error(error instanceof DriveError ? error : signal?.aborted ? new DriveError("aborted") : new DriveError("network_error"));
+			}
+		},
+		async cancel(reason) {
+			if (finished) return;
+			finished = true;
+			removeAbort();
+			await reader.cancel(reason).catch(() => void 0);
+		}
+	});
+}
 async function getCurrentWorkspace(runtime, input) {
 	return execute(runtime, validateCurrentWorkspaceInput(input).signal, null, (api, requestOptions) => api.GET("/api/v1/workspaces/current", {
 		...operationOptions("getCurrentWorkspace", { params: {} }),
 		...requestOptions
 	}), [200], isCurrentWorkspace, false, CURRENT_WORKSPACE_ERROR_CODES);
 }
+async function getItem(runtime, input) {
+	const validated = validateResourceInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/items/{itemId}", {
+		...operationOptions("getItem", { params: { path: resourcePath(validated) } }),
+		...requestOptions
+	}), [200], (value, _status, headers) => isManagedItemMetadata(value, validated.workspaceId, validated.itemId) && itemEtagMatchesRevision(headers, value.revision), false, GET_ITEM_ERROR_CODES);
+}
+async function searchWorkspaceItems(runtime, input) {
+	const validated = validateSearchWorkspaceItemsInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/search", {
+		...operationOptions("searchWorkspaceItems", { params: {
+			path: { workspaceId: validated.workspaceId },
+			query: {
+				query: validated.query,
+				...validated.limit === void 0 ? {} : { limit: validated.limit },
+				...validated.cursor === void 0 ? {} : { cursor: validated.cursor }
+			}
+		} }),
+		...requestOptions
+	}), [200], (value) => isWorkspaceItemSearchPage(value, validated.workspaceId, validated.query, validated.limit ?? 50), false, SEARCH_WORKSPACE_ITEMS_ERROR_CODES);
+}
 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", {
@@ -1320,6 +2232,100 @@ async function createFolder(runtime, input) {
 		...requestOptions
 	}), [200, 201], (value) => isFolderItem(value) && value.workspaceId === validated.workspaceId && value.parentItemId === validated.itemId && value.kind === "folder" && value.name === validated.name);
 }
+async function updateItem(runtime, input) {
+	const validated = validateUpdateItemInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.PATCH("/api/v1/workspaces/{workspaceId}/items/{itemId}", {
+		...operationOptions("updateItem", {
+			params: {
+				path: resourcePath(validated),
+				header: {
+					"Idempotency-Key": validated.idempotencyKey,
+					"If-Match": validated.ifMatch
+				}
+			},
+			body: {
+				name: validated.name,
+				parentItemId: validated.parentItemId
+			}
+		}),
+		...requestOptions
+	}), [200], (value, _status, headers) => isManagedLifecycleItem(value, validated.workspaceId, validated.itemId, "active") && value.name === validated.name && value.parentItemId === validated.parentItemId && itemEtagMatchesRevision(headers, value.revision), false, LIFECYCLE_MUTATION_ERROR_CODES);
+}
+async function trashItem(runtime, input) {
+	const validated = validateLifecycleMutationInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/items/{itemId}/trash", {
+		...operationOptions("trashItem", { params: {
+			path: resourcePath(validated),
+			header: {
+				"Idempotency-Key": validated.idempotencyKey,
+				"If-Match": validated.ifMatch
+			}
+		} }),
+		...requestOptions
+	}), [200], (value, _status, headers) => isManagedLifecycleItem(value, validated.workspaceId, validated.itemId, "trashed") && itemEtagMatchesRevision(headers, value.revision), false, LIFECYCLE_MUTATION_ERROR_CODES);
+}
+async function restoreItem(runtime, input) {
+	const validated = validateLifecycleMutationInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/items/{itemId}/restore", {
+		...operationOptions("restoreItem", { params: {
+			path: resourcePath(validated),
+			header: {
+				"Idempotency-Key": validated.idempotencyKey,
+				"If-Match": validated.ifMatch
+			}
+		} }),
+		...requestOptions
+	}), [200], (value, _status, headers) => isManagedLifecycleItem(value, validated.workspaceId, validated.itemId, "active") && itemEtagMatchesRevision(headers, value.revision), false, LIFECYCLE_MUTATION_ERROR_CODES);
+}
+async function deleteItem(runtime, input) {
+	const validated = validateLifecycleMutationInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.DELETE("/api/v1/workspaces/{workspaceId}/items/{itemId}", {
+		...operationOptions("deleteItem", { params: {
+			path: resourcePath(validated),
+			header: {
+				"Idempotency-Key": validated.idempotencyKey,
+				"If-Match": validated.ifMatch
+			}
+		} }),
+		...requestOptions
+	}), [200, 202], (value, _status, headers) => isManagedLifecycleItem(value, validated.workspaceId, validated.itemId, "deleting") && itemEtagMatchesRevision(headers, value.revision), false, LIFECYCLE_MUTATION_ERROR_CODES);
+}
+async function listItemVersions(runtime, input) {
+	const validated = validatePageInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/items/{itemId}/versions", {
+		...operationOptions("listItemVersions", { params: {
+			path: resourcePath(validated),
+			query: pageQuery(validated)
+		} }),
+		...requestOptions
+	}), [200], (value) => isManagedItemVersionPage(value, validated.limit ?? 50), false, LIST_ITEM_VERSIONS_ERROR_CODES);
+}
+async function getItemVersion(runtime, input) {
+	const validated = validateItemVersionInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/items/{itemId}/versions/{versionId}", {
+		...operationOptions("getItemVersion", { params: { path: {
+			...resourcePath(validated),
+			versionId: validated.versionId
+		} } }),
+		...requestOptions
+	}), [200], (value) => isManagedItemVersionResource(value, validated.workspaceId, validated.itemId, validated.versionId), false, LIST_ITEM_VERSIONS_ERROR_CODES);
+}
+async function restoreItemVersion(runtime, input) {
+	const validated = validateRestoreItemVersionInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/items/{itemId}/versions/{versionId}/restore", {
+		...operationOptions("restoreItemVersion", { params: {
+			path: {
+				...resourcePath(validated),
+				versionId: validated.versionId
+			},
+			header: {
+				"Idempotency-Key": validated.idempotencyKey,
+				"If-Match": validated.ifMatch
+			}
+		} }),
+		...requestOptions
+	}), [200], (value, _status, headers) => isManagedItemVersionRestoreResult(value, validated.versionId) && itemEtagMatchesRevision(headers, value.itemRevision), false, LIFECYCLE_MUTATION_ERROR_CODES);
+}
 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", {
@@ -1405,11 +2411,81 @@ async function createUpload(runtime, input) {
 			},
 			body: {
 				parentItemId: validated.parentItemId,
-				expectedByteLength: validated.expectedByteLength
+				expectedByteLength: validated.expectedByteLength,
+				displayFilename: validated.displayFilename,
+				mediaType: validated.mediaType,
+				callerDeclaredContentDigest: validated.callerDeclaredContentDigest,
+				protectionClassification: validated.protectionClassification
+			}
+		}),
+		...requestOptions
+	}), [200, 201], (value) => isUploadSession(value, validated.expectedByteLength), true, CREATE_UPLOAD_ERROR_CODES);
+}
+async function getUploadStatus(runtime, input) {
+	const validated = validateGetUploadStatusInput(input);
+	const afterPartNumber = validated.afterPartNumber ?? 0;
+	const limit = validated.limit ?? 100;
+	return execute(runtime, validated.signal, null, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}", {
+		...operationOptions("getUploadStatus", { params: {
+			path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId
+			},
+			query: {
+				...validated.afterPartNumber === void 0 ? {} : { afterPartNumber: String(validated.afterPartNumber) },
+				...validated.limit === void 0 ? {} : { limit: String(validated.limit) }
+			}
+		} }),
+		...requestOptions
+	}), [200], (value) => isUploadStatus(value, afterPartNumber, limit), false, STATUS_ERROR_CODES);
+}
+async function createUploadPartDescriptor(runtime, input) {
+	const validated = validateCreateUploadPartDescriptorInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}/parts", {
+		...operationOptions("createUploadPartDescriptor", {
+			params: { path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId
+			} },
+			body: {
+				partNumber: validated.partNumber,
+				checksumSha256: validated.checksumSha256
 			}
 		}),
 		...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);
+	}), [200], (value) => isUploadPartDescriptor(value, validated.partNumber, validated.checksumSha256, new URL(runtime.baseUrl).protocol === "http:"), false, TRANSFER_ERROR_CODES);
+}
+async function recordUploadPart(runtime, input) {
+	const validated = validateRecordUploadPartInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}/parts/{partNumber}", {
+		...operationOptions("recordUploadPart", {
+			params: { path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId,
+				partNumber: String(validated.partNumber)
+			} },
+			body: {
+				expectedUploadRevision: validated.expectedUploadRevision,
+				byteLength: validated.byteLength,
+				etag: validated.etag,
+				checksumSha256: validated.checksumSha256
+			}
+		}),
+		...requestOptions
+	}), [200], (value) => isUploadPartResult(value, validated.partNumber, validated.expectedUploadRevision), false, TRANSFER_ERROR_CODES);
+}
+async function completeUpload(runtime, input) {
+	const validated = validateCompleteUploadInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}/complete", {
+		...operationOptions("completeUpload", { params: {
+			path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId
+			},
+			header: { "Idempotency-Key": validated.idempotencyKey }
+		} }),
+		...requestOptions
+	}), [200], (value) => isReadyUpload(value, { uploadId: validated.uploadId }), false, COMPLETE_UPLOAD_ERROR_CODES);
 }
 async function abortUpload(runtime, input) {
 	const validated = validateAbortUploadInput(input);
@@ -1419,12 +2495,717 @@ async function abortUpload(runtime, input) {
 			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);
+	}), [204], null, false, TRANSFER_ERROR_CODES);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/_u64.js
+const fromNumH = (n) => n / 2 ** 32 | 0;
+const fromNumL = (n) => n >>> 0;
+function setU64FromNum(view, byteOffset, n, isLE) {
+	const h = fromNumH(n);
+	const l = fromNumL(n);
+	view.setUint32(byteOffset, isLE ? l : h, isLE);
+	view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+const atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n, title = "") {
+	if (typeof n !== "number") throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+	if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+	return n;
+}
+function abytes(value, length, title = "") {
+	if (isBytes(value) && (length === void 0 || value.length === length)) return value;
+	if (length !== void 0) anumber(length, "length");
+	const bytes = isBytes(value);
+	const ofLen = length !== void 0 ? ` of length ${length}` : "";
+	const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+	const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+	if (!bytes) throw new TypeError(message);
+	throw new RangeError(message);
+}
+const aobject = (value, label) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+};
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("hash was destroyed");
+	if (checkFinished && instance.finished) throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+	abytes(out, void 0, "output");
+	const min = instance.outputLen;
+	if (!(out.length >= min)) throw new RangeError("\"output\" expected length >= " + min);
+}
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+	return word << 32 - shift | word >>> shift;
+}
+const hasHexBuiltin = (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+const hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+	abytes(bytes);
+	if (hasHexBuiltin) return bytes.toHex();
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+	return hex;
+}
+function checkOpts(defaults, opts, title = "opts") {
+	aobject(defaults, "defaults");
+	if (opts !== void 0) aobject(opts, title);
+	return Object.assign(defaults, opts);
+}
+function createHasher(hashCons, info = {}) {
+	if (typeof hashCons !== "function") throw new TypeError("\"hashCons\" expected function, got type=" + typeof hashCons);
+	info = checkOpts({}, info, "info");
+	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+	const tmp = hashCons(void 0);
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.canXOF = tmp.canXOF;
+	hashC.create = (opts) => hashCons(opts);
+	Object.assign(hashC, info);
+	return Object.freeze(hashC);
+}
+const oidNist = (suffix) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	suffix
+]) });
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+	return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+	return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+	blockLen;
+	outputLen;
+	canXOF = false;
+	padOffset;
+	isLE;
+	buffer;
+	view;
+	finished = false;
+	length = 0;
+	pos = 0;
+	destroyed = false;
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		let processed = false;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				processed = true;
+				continue;
+			}
+			buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+				processed = true;
+			}
+		}
+		this.length += data.length;
+		if (processed) this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		buffer.fill(0, pos);
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			buffer.fill(0);
+		}
+		setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
+		this.process(view, 0);
+		this.roundClean();
+		const oview = out === buffer ? view : createView(out);
+		const len = this.outputLen;
+		const outLen = len / 4;
+		const state = this.get();
+		if (len % 4 || outLen > state.length) throw new Error("invalid outputLen");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneIntoMeta(to) {
+		const { buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (pos) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+const SHA256_IV = Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/sha2.js
+const SHA256_K = Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const SHA256_W = new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+	A = 0;
+	B = 0;
+	C = 0;
+	D = 0;
+	E = 0;
+	F = 0;
+	G = 0;
+	H = 0;
+	constructor(outputLen, IV) {
+		super(64, outputLen, 8, false);
+		this.A = IV[0] | 0;
+		this.B = IV[1] | 0;
+		this.C = IV[2] | 0;
+		this.D = IV[3] | 0;
+		this.E = IV[4] | 0;
+		this.F = IV[5] | 0;
+		this.G = IV[6] | 0;
+		this.H = IV[7] | 0;
+	}
+	get() {
+		const { A, B, C, D, E, F, G, H } = this;
+		return [
+			A,
+			B,
+			C,
+			D,
+			E,
+			F,
+			G,
+			H
+		];
+	}
+	set(A, B, C, D, E, F, G, H) {
+		this.A = A | 0;
+		this.B = B | 0;
+		this.C = C | 0;
+		this.D = D | 0;
+		this.E = E | 0;
+		this.F = F | 0;
+		this.G = G | 0;
+		this.H = H | 0;
+	}
+	_cloneInto(to) {
+		(to ||= new this.constructor()).set(...this.get());
+		return this._cloneIntoMeta(to);
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+		for (let i = 16; i < 64; i++) {
+			const W15 = SHA256_W[i - 15];
+			const W2 = SHA256_W[i - 2];
+			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+		}
+		let { A, B, C, D, E, F, G, H } = this;
+		for (let i = 0; i < 64; i++) {
+			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
+			H = G;
+			G = F;
+			F = E;
+			E = D + T1 | 0;
+			D = C;
+			C = B;
+			B = A;
+			A = T1 + T2 | 0;
+		}
+		A = A + this.A | 0;
+		B = B + this.B | 0;
+		C = C + this.C | 0;
+		D = D + this.D | 0;
+		E = E + this.E | 0;
+		F = F + this.F | 0;
+		G = G + this.G | 0;
+		H = H + this.H | 0;
+		this.set(A, B, C, D, E, F, G, H);
+	}
+	roundClean() {
+		clean(SHA256_W);
+	}
+	destroy() {
+		this.destroyed = true;
+		this.set(0, 0, 0, 0, 0, 0, 0, 0);
+		clean(this.buffer);
+	}
+};
+var _SHA256 = class extends SHA2_32B {
+	constructor() {
+		super(32, SHA256_IV);
+	}
+};
+const sha256 = createHasher(() => new _SHA256(), oidNist(1));
+//#endregion
+//#region src/internal/client/upload.ts
+const UPLOAD_PART_BYTE_LENGTH = 32 * 1024 * 1024;
+const STATUS_PAGE_LIMIT = 100;
+const STATUS_PAGE_MAXIMUM = 100;
+const ABORT_DEADLINE_MILLISECONDS = 5e3;
+async function uploadFileInternal(runtime, input, controls) {
+	const validated = validateUploadFileInput(input);
+	const totalPartCount = Math.ceil(validated.byteLength / UPLOAD_PART_BYTE_LENGTH);
+	emitProgress(validated.onProgress, "preparing", 0, validated.byteLength, 0, totalPartCount);
+	let session;
+	try {
+		const digests = await hashSource(validated.source, validated.byteLength, totalPartCount, validated.signal);
+		const created = await controls.createUpload({
+			workspaceId: validated.workspaceId,
+			parentItemId: validated.parentItemId,
+			expectedByteLength: validated.byteLength,
+			displayFilename: validated.displayFilename,
+			mediaType: validated.mediaType,
+			callerDeclaredContentDigest: digests.callerDeclaredContentDigest,
+			protectionClassification: validated.protectionClassification,
+			idempotencyKey: validated.idempotencyKey,
+			...validated.signal === void 0 ? {} : { signal: validated.signal }
+		});
+		session = created.data;
+		assertSessionPolicy(session, validated.byteLength, totalPartCount, created.status, created.requestId);
+		const resumed = await readResumeState(controls, validated, session, digests);
+		emitProgress(validated.onProgress, "uploading", resumed.confirmedByteLength, validated.byteLength, resumed.confirmedParts.size, totalPartCount);
+		if (resumed.readyResult) {
+			emitProgress(validated.onProgress, "completing", resumed.confirmedByteLength, validated.byteLength, resumed.confirmedParts.size, totalPartCount);
+			return resumed.readyResult;
+		}
+		let revision = resumed.revision;
+		let confirmedByteLength = resumed.confirmedByteLength;
+		let confirmedPartCount = resumed.confirmedParts.size;
+		if (resumed.lifecycle === "uploading") for (const partNumber of pendingUploadPartNumbers(session.partCount, resumed.confirmedParts)) {
+			const index = partNumber - 1;
+			throwIfCallerAborted(validated.signal);
+			const start = index * session.partByteLength;
+			const end = Math.min(start + session.partByteLength, validated.byteLength);
+			const expectedByteLength = end - start;
+			const checksumSha256 = digests.partChecksums[index];
+			if (!checksumSha256) throw new DriveError("invalid_response");
+			const descriptorResult = await controls.createUploadPartDescriptor({
+				workspaceId: validated.workspaceId,
+				uploadId: session.uploadId,
+				partNumber,
+				checksumSha256,
+				...validated.signal === void 0 ? {} : { signal: validated.signal }
+			});
+			const descriptor = descriptorResult.data;
+			if (descriptor.expectedByteLength !== expectedByteLength || descriptor.expiresAtEpochMilliseconds > session.expiresAtEpochMilliseconds) throw new DriveError("invalid_response", {
+				status: descriptorResult.status,
+				requestId: descriptorResult.requestId
+			});
+			const etag = await putPart(runtime, descriptor, slicePart(validated.source, start, end, expectedByteLength), checksumSha256, validated.signal);
+			revision = await recordPartWithReconciliation(controls, validated, session, partNumber, revision, expectedByteLength, etag, checksumSha256);
+			confirmedByteLength += expectedByteLength;
+			confirmedPartCount += 1;
+			emitProgress(validated.onProgress, "uploading", confirmedByteLength, validated.byteLength, confirmedPartCount, totalPartCount);
+		}
+		emitProgress(validated.onProgress, "completing", confirmedByteLength, validated.byteLength, confirmedPartCount, totalPartCount);
+		return await completeWithReconciliation(controls, validated, session, digests);
+	} catch (error) {
+		if (validated.signal?.aborted && session) await bestEffortAbort(controls, validated.workspaceId, session.uploadId);
+		if (error instanceof DriveError) throw error;
+		throw validated.signal?.aborted ? new DriveError("aborted") : new DriveError("invalid_input");
+	}
+}
+function* pendingUploadPartNumbers(partCount, confirmedParts) {
+	for (let partNumber = 1; partNumber <= partCount; partNumber += 1) if (!confirmedParts.has(partNumber)) yield partNumber;
+}
+async function readResumeState(controls, input, session, digests) {
+	const confirmedParts = new Set();
+	let confirmedByteLength = 0;
+	let afterPartNumber = 0;
+	let baseline;
+	let baselineRequestId;
+	let readyResult;
+	for (let pageNumber = 0; pageNumber < STATUS_PAGE_MAXIMUM; pageNumber += 1) {
+		const result = await controls.getUploadStatus({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			afterPartNumber,
+			limit: STATUS_PAGE_LIMIT,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		const status = result.data;
+		assertStatusMatchesSession(status, session);
+		if (baseline) assertSameStatusSnapshot(status, baseline);
+		else {
+			baseline = status;
+			baselineRequestId = result.requestId;
+		}
+		for (const part of status.confirmedParts) {
+			const expectedChecksum = digests.partChecksums[part.partNumber - 1];
+			if (!expectedChecksum || part.checksumSha256 !== expectedChecksum || confirmedParts.has(part.partNumber)) throw new DriveError("invalid_response", {
+				status: result.status,
+				requestId: result.requestId
+			});
+			confirmedParts.add(part.partNumber);
+			confirmedByteLength += expectedPartByteLength(input.byteLength, part.partNumber);
+		}
+		if (status.lifecycle === "ready" && status.ready) {
+			assertReadyMatchesInput(status.ready, session, input, digests, result.requestId);
+			readyResult = resultFromStatus(result, status.ready);
+		}
+		if (status.nextAfterPartNumber === null) break;
+		if (pageNumber === STATUS_PAGE_MAXIMUM - 1) throw new DriveError("invalid_response", {
+			status: result.status,
+			requestId: result.requestId
+		});
+		afterPartNumber = status.nextAfterPartNumber;
+	}
+	if (!baseline) throw new DriveError("invalid_response");
+	if (session.mode === "presigned-multipart" && [
+		"completing",
+		"provider-completed",
+		"ready"
+	].includes(baseline.lifecycle) && confirmedParts.size !== session.partCount) throw new DriveError("invalid_response");
+	failForTerminalStatus(baseline.lifecycle, baselineRequestId);
+	return Object.freeze({
+		revision: baseline.revision,
+		confirmedParts,
+		confirmedByteLength,
+		lifecycle: baseline.lifecycle,
+		...readyResult === void 0 ? {} : { readyResult }
+	});
+}
+async function recordPartWithReconciliation(controls, input, session, partNumber, expectedUploadRevision, byteLength, etag, checksumSha256) {
+	const record = (revision) => controls.recordUploadPart({
+		workspaceId: input.workspaceId,
+		uploadId: session.uploadId,
+		partNumber,
+		expectedUploadRevision: revision,
+		byteLength,
+		etag,
+		checksumSha256,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	try {
+		return (await record(expectedUploadRevision)).data.revision;
+	} catch (error) {
+		if (!isAmbiguousControlFailure(error) || input.signal?.aborted) throw error;
+		const statusResult = await controls.getUploadStatus({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			afterPartNumber: partNumber - 1,
+			limit: 1,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		const status = statusResult.data;
+		assertStatusMatchesSession(status, session);
+		failForTerminalStatus(status.lifecycle, statusResult.requestId);
+		const confirmed = status.confirmedParts.find((part) => part.partNumber === partNumber);
+		if (confirmed) {
+			if (confirmed.checksumSha256 !== checksumSha256) throw new DriveError("invalid_response", {
+				status: statusResult.status,
+				requestId: statusResult.requestId
+			});
+			return status.revision;
+		}
+		if (status.lifecycle !== "uploading") throw new DriveError("precondition_failed");
+		return (await record(status.revision)).data.revision;
+	}
+}
+async function completeWithReconciliation(controls, input, session, digests) {
+	try {
+		const completed = await controls.completeUpload({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			idempotencyKey: input.completionIdempotencyKey,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		assertReadyMatchesInput(completed.data, session, input, digests, completed.requestId);
+		return completed;
+	} catch (error) {
+		if (!isAmbiguousControlFailure(error) || input.signal?.aborted) throw error;
+		const statusResult = await controls.getUploadStatus({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			afterPartNumber: 0,
+			limit: 1,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		const status = statusResult.data;
+		assertStatusMatchesSession(status, session);
+		if (status.lifecycle !== "ready" || !status.ready) throw error;
+		assertReadyMatchesInput(status.ready, session, input, digests, statusResult.requestId);
+		return resultFromStatus(statusResult, status.ready);
+	}
+}
+async function hashSource(source, byteLength, partCount, signal) {
+	const fullHash = sha256.create();
+	const partChecksums = [];
+	for (let index = 0; index < partCount; index += 1) {
+		throwIfCallerAborted(signal);
+		const start = index * UPLOAD_PART_BYTE_LENGTH;
+		const end = Math.min(start + UPLOAD_PART_BYTE_LENGTH, byteLength);
+		const part = slicePart(source, start, end, end - start);
+		let buffer;
+		try {
+			buffer = signal ? await raceWithAbort(part.arrayBuffer(), signal) : await part.arrayBuffer();
+		} catch (error) {
+			if (error instanceof DriveError) throw error;
+			throw signal?.aborted ? new DriveError("aborted") : new DriveError("invalid_input");
+		}
+		if (buffer.byteLength !== end - start) throw new DriveError("invalid_input");
+		const bytes = new Uint8Array(buffer);
+		fullHash.update(bytes);
+		partChecksums.push(toBase64(sha256(bytes)));
+	}
+	return Object.freeze({
+		callerDeclaredContentDigest: `sha256:${bytesToHex(fullHash.digest())}`,
+		partChecksums: Object.freeze(partChecksums)
+	});
+}
+async function putPart(runtime, descriptor, part, checksumSha256, callerSignal) {
+	const remainingMilliseconds = descriptor.expiresAtEpochMilliseconds - Date.now();
+	if (remainingMilliseconds < 1) throw new DriveError("invalid_response");
+	const operation = createOperationSignal(callerSignal, Math.min(runtime.timeoutMilliseconds, remainingMilliseconds));
+	let response;
+	try {
+		response = await raceWithAbort(runtime.fetchImplementation(descriptor.url, {
+			method: descriptor.method,
+			body: part,
+			headers: descriptor.headers,
+			credentials: "omit",
+			cache: "no-store",
+			redirect: "error",
+			referrerPolicy: "no-referrer",
+			signal: operation.signal
+		}), operation.signal);
+		if (!(response instanceof Response)) throw new DriveError("invalid_response");
+		const etag = response.headers.get("etag");
+		const responseChecksum = response.headers.get("x-amz-checksum-sha256");
+		if (response.status < 200 || response.status > 299 || !isEtag(etag) || responseChecksum !== checksumSha256) throw new DriveError("invalid_response", { status: response.status });
+		return etag;
+	} catch (error) {
+		if (operation.didTimeout()) throw new DriveError("timeout");
+		if (callerSignal?.aborted) throw new DriveError("aborted");
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("network_error");
+	} finally {
+		operation.dispose();
+		response?.body?.cancel().catch(() => {});
+	}
+}
+function assertSessionPolicy(session, byteLength, partCount, status, requestId) {
+	const expectedMode = byteLength === 0 ? "server-mediated-zero-byte" : "presigned-multipart";
+	if (session.mode !== expectedMode || session.partByteLength !== UPLOAD_PART_BYTE_LENGTH || session.partCount !== partCount || session.expiresAtEpochMilliseconds <= Date.now()) throw new DriveError("invalid_response", {
+		status,
+		requestId
+	});
+}
+function assertStatusMatchesSession(status, session) {
+	if (status.itemId !== session.itemId || status.versionId !== session.versionId || status.uploadId !== session.uploadId || status.mode !== session.mode || status.revision < session.revision || status.partPolicy.partByteLength !== session.partByteLength || status.partPolicy.partCount !== session.partCount || status.partPolicy.maxParts !== 1e4 || status.expiresAtEpochMilliseconds !== session.expiresAtEpochMilliseconds) throw new DriveError("invalid_response");
+}
+function assertSameStatusSnapshot(status, baseline) {
+	if (status.itemId !== baseline.itemId || status.versionId !== baseline.versionId || status.uploadId !== baseline.uploadId || status.mode !== baseline.mode || status.lifecycle !== baseline.lifecycle || status.revision !== baseline.revision || status.partPolicy.partByteLength !== baseline.partPolicy.partByteLength || status.partPolicy.partCount !== baseline.partPolicy.partCount || status.partPolicy.maxParts !== baseline.partPolicy.maxParts || status.expiresAtEpochMilliseconds !== baseline.expiresAtEpochMilliseconds || JSON.stringify(status.ready) !== JSON.stringify(baseline.ready)) throw new DriveError("invalid_response");
+}
+function assertReadyMatchesInput(ready, session, input, digests, requestId) {
+	if (ready.itemId !== session.itemId || ready.versionId !== session.versionId || ready.uploadId !== session.uploadId || ready.byteLength !== input.byteLength || ready.callerDeclaredContentDigest !== digests.callerDeclaredContentDigest || ready.displayFilename !== input.displayFilename || ready.mediaType !== input.mediaType) throw new DriveError("invalid_response", {
+		status: 200,
+		requestId
+	});
+}
+function failForTerminalStatus(lifecycle, requestId) {
+	if (lifecycle === "initiating" || lifecycle === "recovery-required") throw new DriveError("upload_recovery_required", {
+		status: 409,
+		...requestId === void 0 ? {} : { requestId }
+	});
+	if (lifecycle === "aborting" || lifecycle === "aborted") throw new DriveError("precondition_failed", {
+		status: 409,
+		...requestId === void 0 ? {} : { requestId }
+	});
+}
+function resultFromStatus(status, ready) {
+	return Object.freeze({
+		data: ready,
+		status: status.status,
+		requestId: status.requestId,
+		validators: status.validators
+	});
+}
+function expectedPartByteLength(byteLength, partNumber) {
+	return Math.min(UPLOAD_PART_BYTE_LENGTH, byteLength - (partNumber - 1) * UPLOAD_PART_BYTE_LENGTH);
+}
+function slicePart(source, start, end, expectedByteLength) {
+	try {
+		const part = source.slice(start, end);
+		if (!(part instanceof Blob) || part.size !== expectedByteLength) throw new DriveError("invalid_input");
+		return part;
+	} catch (error) {
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("invalid_input");
+	}
+}
+function emitProgress(callback, phase, confirmedByteLength, totalByteLength, confirmedPartCount, totalPartCount) {
+	if (!callback) return;
+	const progress = Object.freeze({
+		phase,
+		confirmedByteLength,
+		totalByteLength,
+		confirmedPartCount,
+		totalPartCount
+	});
+	try {
+		callback(progress);
+	} catch {}
+}
+async function bestEffortAbort(controls, workspaceId, uploadId) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), ABORT_DEADLINE_MILLISECONDS);
+	try {
+		await controls.abortUpload({
+			workspaceId,
+			uploadId,
+			signal: controller.signal
+		});
+	} catch {} finally {
+		clearTimeout(timeout);
+	}
+}
+function isAmbiguousControlFailure(value) {
+	return value instanceof DriveError && (value.code === "network_error" || value.code === "timeout" || value.code === "invalid_response");
+}
+function throwIfCallerAborted(signal) {
+	if (signal?.aborted) throw new DriveError("aborted");
+}
+function toBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function isEtag(value) {
+	return value !== null && value.length >= 1 && value.length <= 1024 && /^[\x20-\x7e]+$/.test(value);
 }
 //#endregion
 //#region src/client.ts
 function createDriveClient(config) {
-	return createDriveClientInternal(config);
+	const runtime = createClientRuntime(config);
+	const operations = createDriveOperations(runtime);
+	return Object.freeze({
+		...operations,
+		uploadFile: (input) => uploadFileInternal(runtime, input, operations)
+	});
 }
 //#endregion
 export { createDriveClient };