@backblaze-labs/b2-sdk 0.1.0 → 0.2.0

package/dist/raw/index.js

@@ -1,601 +1,686 @@
-import { normalizeFileVersionSha1, normalizeFileVersionListSha1 } from "../util/normalize.js";
-import { buildFileInfoHeaders, encodeFileName } from "./encoding.js";
-import { decodeFileName, parseFileInfoHeaders } from "./encoding.js";
-import { EncryptionMode, EncryptionAlgorithm } from "../types/encryption.js";
-class RawClient {
-  /** @internal */
-  transport;
-  /**
-   * Creates a new RawClient with the given transport.
-   * @param options - The constructor configuration.
-   */
-  constructor(options) {
-    this.transport = options.transport;
-  }
-  // --- Auth ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-authorize-account | b2_authorize_account}.
-   * @param applicationKeyId - The application key ID for authentication.
-   * @param applicationKey - The application key secret.
-   * @param realmUrl - The B2 realm URL to authenticate against.
-   *
-   * @returns The authorization response with API URLs and credentials.
-   */
-  async authorizeAccount(applicationKeyId, applicationKey, realmUrl = "https://api.backblazeb2.com") {
-    const response = await this.transport.send({
-      url: `${realmUrl}/b2api/v3/b2_authorize_account`,
-      method: "GET",
-      headers: {
-        Authorization: `Basic ${btoa(`${applicationKeyId}:${applicationKey}`)}`
-      }
-    });
-    return response.json();
-  }
-  // --- Buckets ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-create-bucket | b2_create_bucket}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The created bucket metadata.
-   */
-  async createBucket(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_create_bucket", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-delete-bucket | b2_delete_bucket}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The deleted bucket metadata.
-   */
-  async deleteBucket(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_delete_bucket", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-list-buckets | b2_list_buckets}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The list of matching buckets.
-   */
-  async listBuckets(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_list_buckets", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-update-bucket | b2_update_bucket}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The updated bucket metadata.
-   */
-  async updateBucket(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_update_bucket", request);
-  }
-  // --- Files ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-get-upload-url | b2_get_upload_url}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The upload URL and authorization token.
-   */
-  async getUploadUrl(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_get_upload_url", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-upload-file | b2_upload_file}.
-   *
-   * Unlike most methods, this posts directly to the `uploadUrl` obtained
-   * from {@link getUploadUrl} rather than the API URL.
-   * @param uploadUrl - The upload endpoint URL.
-   * @param headers - The request headers including authorization and content metadata.
-   * @param body - The file data to upload.
-   * @param signal - An optional abort signal for cancellation.
-   *
-   * @returns The uploaded file version metadata.
-   */
-  async uploadFile(uploadUrl, headers, body, signal) {
-    const reqHeaders = {
-      Authorization: headers.authorization,
-      "X-Bz-File-Name": encodeFileName(headers.fileName),
-      "Content-Type": headers.contentType,
-      "Content-Length": String(headers.contentLength),
-      "X-Bz-Content-Sha1": headers.contentSha1,
-      ...buildFileInfoHeaders(headers.fileInfo)
-    };
-    if (headers.lastModifiedMillis !== void 0) {
-      reqHeaders["X-Bz-Info-src_last_modified_millis"] = String(headers.lastModifiedMillis);
-    }
-    if (headers.contentDisposition) {
-      reqHeaders["X-Bz-Info-b2-content-disposition"] = headers.contentDisposition;
-    }
-    if (headers.contentLanguage) {
-      reqHeaders["X-Bz-Info-b2-content-language"] = headers.contentLanguage;
-    }
-    if (headers.expires) {
-      reqHeaders["X-Bz-Info-b2-expires"] = headers.expires;
-    }
-    if (headers.cacheControl) {
-      reqHeaders["X-Bz-Info-b2-cache-control"] = headers.cacheControl;
-    }
-    if (headers.contentEncoding) {
-      reqHeaders["X-Bz-Info-b2-content-encoding"] = headers.contentEncoding;
-    }
-    applyEncryptionHeaders(reqHeaders, headers.serverSideEncryption);
-    applyRetentionHeaders(reqHeaders, headers.fileRetention);
-    applyLegalHoldHeader(reqHeaders, headers.legalHold);
-    const response = await this.transport.send({
-      url: uploadUrl,
-      method: "POST",
-      headers: reqHeaders,
-      body,
-      ...signal !== void 0 ? { signal } : {}
-    });
-    return normalizeFileVersionSha1(await response.json());
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-list-file-names | b2_list_file_names}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The list of file names and optional continuation token.
-   */
-  async listFileNames(apiUrl, authToken, request) {
-    return normalizeFileVersionListSha1(
-      await this.postJson(apiUrl, authToken, "b2_list_file_names", request)
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-list-file-versions | b2_list_file_versions}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The list of file versions and optional continuation token.
-   */
-  async listFileVersions(apiUrl, authToken, request) {
-    return normalizeFileVersionListSha1(
-      await this.postJson(
-        apiUrl,
-        authToken,
-        "b2_list_file_versions",
-        request
-      )
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-get-file-info | b2_get_file_info}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The file version metadata.
-   */
-  async getFileInfo(apiUrl, authToken, request) {
-    return normalizeFileVersionSha1(
-      await this.postJson(apiUrl, authToken, "b2_get_file_info", request)
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-hide-file | b2_hide_file}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The hidden file version metadata.
-   */
-  async hideFile(apiUrl, authToken, request) {
-    return normalizeFileVersionSha1(
-      await this.postJson(apiUrl, authToken, "b2_hide_file", request)
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-delete-file-version | b2_delete_file_version}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The deleted file version identifier.
-   */
-  async deleteFileVersion(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_delete_file_version",
-      request
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-copy-file | b2_copy_file}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The copied file version metadata.
-   */
-  async copyFile(apiUrl, authToken, request) {
-    return normalizeFileVersionSha1(
-      await this.postJson(apiUrl, authToken, "b2_copy_file", request)
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-copy-part | b2_copy_part}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The copied part metadata.
-   */
-  async copyPart(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_copy_part", request);
-  }
-  // --- Large Files ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-start-large-file | b2_start_large_file}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The started large file metadata with file ID.
-   */
-  async startLargeFile(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_start_large_file", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-get-upload-part-url | b2_get_upload_part_url}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The upload part URL and authorization token.
-   */
-  async getUploadPartUrl(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_get_upload_part_url",
-      request
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-upload-part | b2_upload_part}.
-   *
-   * Posts directly to the `uploadUrl` obtained from {@link getUploadPartUrl}
-   * rather than the API URL.
-   * @param uploadUrl - The upload endpoint URL.
-   * @param headers - The request headers including authorization and content metadata.
-   * @param body - The file data to upload.
-   * @param signal - An optional abort signal for cancellation.
-   *
-   * @returns The uploaded part metadata.
-   */
-  async uploadPart(uploadUrl, headers, body, signal) {
-    const reqHeaders = {
-      Authorization: headers.authorization,
-      "X-Bz-Part-Number": String(headers.partNumber),
-      "Content-Length": String(headers.contentLength),
-      "X-Bz-Content-Sha1": headers.contentSha1
-    };
-    applyEncryptionHeaders(reqHeaders, headers.serverSideEncryption);
-    const response = await this.transport.send({
-      url: uploadUrl,
-      method: "POST",
-      headers: reqHeaders,
-      body,
-      ...signal !== void 0 ? { signal } : {}
-    });
-    return response.json();
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-finish-large-file | b2_finish_large_file}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The completed file version metadata.
-   */
-  async finishLargeFile(apiUrl, authToken, request) {
-    return normalizeFileVersionSha1(
-      await this.postJson(apiUrl, authToken, "b2_finish_large_file", request)
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-cancel-large-file | b2_cancel_large_file}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The cancelled large file metadata.
-   */
-  async cancelLargeFile(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_cancel_large_file",
-      request
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-list-unfinished-large-files | b2_list_unfinished_large_files}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The list of unfinished large files and optional continuation token.
-   */
-  async listUnfinishedLargeFiles(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_list_unfinished_large_files",
-      request
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-list-parts | b2_list_parts}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The list of uploaded parts and optional continuation token.
-   */
-  async listParts(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_list_parts", request);
-  }
-  // --- Downloads ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-download-file-by-id | b2_download_file_by_id}.
-   * @param downloadUrl - The B2 download base URL.
-   * @param authToken - The authorization token.
-   * @param fileId - The unique identifier of the file to download.
-   * @param options - Optional download parameters for range requests and cancellation.
-   *
-   * @returns The response headers, streaming body, and HTTP status code.
-   */
-  async downloadFileById(downloadUrl, authToken, fileId, options) {
-    const headers = buildDownloadRequestHeaders(authToken, options);
-    const url = appendDownloadOverrides(
-      `${downloadUrl}/b2api/v3/b2_download_file_by_id?fileId=${encodeURIComponent(fileId)}`,
-      options
-    );
-    const response = await this.transport.send({
-      url,
-      method: options?.method ?? "GET",
-      headers,
-      ...options?.signal !== void 0 ? { signal: options.signal } : {}
-    });
-    return { headers: response.headers, body: response.body, status: response.status };
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-download-file-by-name | b2_download_file_by_name}.
-   * @param downloadUrl - The B2 download base URL.
-   * @param authToken - The authorization token.
-   * @param bucketName - The name of the bucket containing the file.
-   * @param fileName - The name of the file to download.
-   * @param options - Optional download parameters for range requests and cancellation.
-   *
-   * @returns The response headers, streaming body, and HTTP status code.
-   */
-  async downloadFileByName(downloadUrl, authToken, bucketName, fileName, options) {
-    const headers = buildDownloadRequestHeaders(authToken, options);
-    const url = appendDownloadOverrides(
-      `${downloadUrl}/file/${encodeURIComponent(bucketName)}/${encodeFileName(fileName)}`,
-      options
-    );
-    const response = await this.transport.send({
-      url,
-      method: options?.method ?? "GET",
-      headers,
-      ...options?.signal !== void 0 ? { signal: options.signal } : {}
-    });
-    return { headers: response.headers, body: response.body, status: response.status };
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-get-download-authorization | b2_get_download_authorization}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The current session authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The download authorization token for the specified file prefix.
-   */
-  async getDownloadAuthorization(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_get_download_authorization",
-      request
-    );
-  }
-  // --- Keys ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-create-key | b2_create_key}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The newly created application key with secret.
-   */
-  async createKey(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_create_key", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-list-keys | b2_list_keys}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The list of application keys and optional continuation token.
-   */
-  async listKeys(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_list_keys", request);
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-delete-key | b2_delete_key}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The deleted application key metadata.
-   */
-  async deleteKey(apiUrl, authToken, request) {
-    return this.postJson(apiUrl, authToken, "b2_delete_key", request);
-  }
-  // --- Retention / Legal Hold ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-update-file-retention | b2_update_file_retention}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The updated file retention settings.
-   */
-  async updateFileRetention(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_update_file_retention",
-      request
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-update-file-legal-hold | b2_update_file_legal_hold}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The updated file legal hold status.
-   */
-  async updateFileLegalHold(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_update_file_legal_hold",
-      request
-    );
-  }
-  // --- Notifications ---
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-get-bucket-notification-rules | b2_get_bucket_notification_rules}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The configured event notification rules for the specified bucket.
-   */
-  async getBucketNotificationRules(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_get_bucket_notification_rules",
-      request
-    );
-  }
-  /**
-   * Calls {@link https://www.backblaze.com/apidocs/b2-set-bucket-notification-rules | b2_set_bucket_notification_rules}.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param request - The API request parameters.
-   *
-   * @returns The updated bucket notification rules.
-   */
-  async setBucketNotificationRules(apiUrl, authToken, request) {
-    return this.postJson(
-      apiUrl,
-      authToken,
-      "b2_set_bucket_notification_rules",
-      request
-    );
-  }
-  // --- Internal ---
-  /**
-   * Sends a JSON POST request to the specified B2 API endpoint.
-   * @param apiUrl - The B2 API base URL.
-   * @param authToken - The authorization token.
-   * @param endpoint - The B2 API endpoint name.
-   * @param body - The JSON request body.
-   *
-   * @returns The parsed JSON response.
-   */
-  async postJson(apiUrl, authToken, endpoint, body) {
-    const response = await this.transport.send({
-      url: `${apiUrl}/b2api/v3/${endpoint}`,
-      method: "POST",
-      headers: {
-        Authorization: authToken,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    return response.json();
-  }
+import { FinishLargeFileResponseBodyError, UploadResponseBodyError } from "../errors/index.js";
+import { buildFileInfoHeaders, decodeFileName, encodeFileName, parseFileInfoHeaders } from "./encoding.js";
+import { normalizeFileVersionListSha1, normalizeFileVersionSha1 } from "../util/normalize.js";
+import { EncryptionAlgorithm, EncryptionMode } from "../types/encryption.js";
+import { assertSecureRealmUrl } from "../auth/realms.js";
+//#region src/raw/index.ts
+/**
+* Low-level 1:1 bindings for every B2 native API endpoint.
+*
+* Each method on {@link RawClient} maps directly to a single `b2_*` HTTP call
+* with fully typed request and response objects. No retry logic, no URL pooling,
+* no automatic reauthorization. Use this when you need precise control over
+* individual API calls; for most use cases prefer the high-level `B2Client`.
+*
+* @packageDocumentation
+*/
+function normalizeRawRequestOptions(optionsOrSignal, retry) {
+	if (optionsOrSignal === void 0) return retry === void 0 ? void 0 : { retry };
+	if (isAbortSignal(optionsOrSignal)) return {
+		signal: optionsOrSignal,
+		...retry !== void 0 ? { retry } : {}
+	};
+	return retry === void 0 ? optionsOrSignal : {
+		...optionsOrSignal,
+		retry
+	};
 }
+function isAbortSignal(value) {
+	return typeof value === "object" && value !== null && "aborted" in value && typeof value.addEventListener === "function";
+}
+function normalizeCreateKeyRequest(request) {
+	const { bucketId, ...withoutDeprecatedBucketId } = request;
+	if (bucketId !== void 0 && withoutDeprecatedBucketId.bucketIds !== void 0) throw new TypeError("createKey accepts either bucketIds or deprecated bucketId, not both");
+	if (bucketId === void 0) return withoutDeprecatedBucketId;
+	return {
+		...withoutDeprecatedBucketId,
+		bucketIds: [bucketId]
+	};
+}
+function singleBucketId(bucketIds) {
+	return bucketIds?.length === 1 ? bucketIds[0] ?? null : null;
+}
+function normalizeKeyResponse(key) {
+	return {
+		...key,
+		bucketId: singleBucketId(key.bucketIds)
+	};
+}
+function normalizeAllowedBuckets(storageApi) {
+	const allowed = storageApi.allowed;
+	if (allowed?.buckets !== void 0) return allowed.buckets === null ? null : allowed.buckets.map((bucket) => ({ ...bucket }));
+	const bucketId = allowed?.bucketId ?? storageApi.bucketId ?? null;
+	if (bucketId === null) return null;
+	return [{
+		id: bucketId,
+		name: allowed?.bucketName ?? storageApi.bucketName ?? null
+	}];
+}
+function normalizeAuthorizeAccountResponse(response) {
+	const storageApi = response.apiInfo.storageApi;
+	const allowed = storageApi.allowed;
+	const buckets = normalizeAllowedBuckets(storageApi);
+	const singleBucket = buckets?.length === 1 ? buckets[0] : void 0;
+	const bucketId = singleBucket?.id ?? null;
+	const bucketName = singleBucket?.name ?? null;
+	const namePrefix = allowed?.namePrefix ?? storageApi.namePrefix ?? null;
+	const capabilities = allowed?.capabilities ?? storageApi.capabilities ?? [];
+	const { allowed: _wireAllowed, capabilities: _legacyCapabilities, ...storageApiBase } = storageApi;
+	return {
+		...response,
+		apiInfo: {
+			...response.apiInfo,
+			storageApi: {
+				...storageApiBase,
+				bucketId,
+				bucketName,
+				downloadUrl: storageApi.downloadUrl,
+				infoType: "storageApi",
+				namePrefix,
+				allowed: {
+					...allowed ?? {},
+					capabilities,
+					buckets,
+					bucketId,
+					bucketName,
+					namePrefix
+				}
+			}
+		}
+	};
+}
+function uploadResponseBodyError(err, signal) {
+	if (signal?.aborted === true) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+	return new UploadResponseBodyError(err instanceof Error ? err.message : "Upload response body could not be read", { cause: err });
+}
+/**
+* Low-level client providing 1:1 bindings to all B2 native API endpoints.
+*
+* Each method maps directly to a single B2 API call. Most methods accept
+* `(apiUrl, authToken, request)` and return the JSON response. Upload and
+* download methods accept endpoint-specific parameters instead.
+*/
+var RawClient = class {
+	/** @internal */
+	transport;
+	/**
+	* Creates a new RawClient with the given transport.
+	* @param options - The constructor configuration.
+	*/
+	constructor(options) {
+		this.transport = options.transport;
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-authorize-account | b2_authorize_account}.
+	* @param applicationKeyId - The application key ID for authentication.
+	* @param applicationKey - The application key secret.
+	* @param realmUrl - The B2 realm URL to authenticate against.
+	*
+	* @returns The authorization response with API URLs and credentials.
+	*/
+	async authorizeAccount(applicationKeyId, applicationKey, realmUrl = "https://api.backblazeb2.com") {
+		assertSecureRealmUrl(realmUrl);
+		return normalizeAuthorizeAccountResponse(await (await this.transport.send({
+			url: `${realmUrl}/b2api/v4/b2_authorize_account`,
+			method: "GET",
+			headers: { Authorization: `Basic ${btoa(`${applicationKeyId}:${applicationKey}`)}` }
+		})).json());
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-create-bucket | b2_create_bucket}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The created bucket metadata.
+	*/
+	async createBucket(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_create_bucket", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-delete-bucket | b2_delete_bucket}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The deleted bucket metadata.
+	*/
+	async deleteBucket(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_delete_bucket", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-list-buckets | b2_list_buckets}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The list of matching buckets.
+	*/
+	async listBuckets(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_list_buckets", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-update-bucket | b2_update_bucket}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The updated bucket metadata.
+	*/
+	async updateBucket(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_update_bucket", request);
+	}
+	/**
+	* Implementation for both upload URL request-control signatures.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param optionsOrSignal - Options bag or legacy abort signal.
+	* @param retry - Optional legacy per-request retry override.
+	*
+	* @returns The upload URL and authorization token.
+	*/
+	async getUploadUrl(apiUrl, authToken, request, optionsOrSignal, retry) {
+		return this.postJson(apiUrl, authToken, "b2_get_upload_url", request, normalizeRawRequestOptions(optionsOrSignal, retry));
+	}
+	/**
+	* Implementation for both upload-file request-control signatures.
+	* @param uploadUrl - The upload endpoint URL.
+	* @param headers - The request headers including authorization and content metadata.
+	* @param body - The file data to upload.
+	* @param optionsOrSignal - Options bag or legacy abort signal.
+	* @param retry - Optional legacy per-request retry override.
+	*
+	* @returns The uploaded file version metadata.
+	*/
+	async uploadFile(uploadUrl, headers, body, optionsOrSignal, retry) {
+		const options = normalizeRawRequestOptions(optionsOrSignal, retry);
+		const reqHeaders = {
+			Authorization: headers.authorization,
+			"X-Bz-File-Name": encodeFileName(headers.fileName),
+			"Content-Type": headers.contentType,
+			"Content-Length": String(headers.contentLength),
+			"X-Bz-Content-Sha1": headers.contentSha1,
+			...buildFileInfoHeaders(headers.fileInfo)
+		};
+		if (headers.lastModifiedMillis !== void 0) reqHeaders["X-Bz-Info-src_last_modified_millis"] = String(headers.lastModifiedMillis);
+		if (headers.contentDisposition) reqHeaders["X-Bz-Info-b2-content-disposition"] = headers.contentDisposition;
+		if (headers.contentLanguage) reqHeaders["X-Bz-Info-b2-content-language"] = headers.contentLanguage;
+		if (headers.expires) reqHeaders["X-Bz-Info-b2-expires"] = headers.expires;
+		if (headers.cacheControl) reqHeaders["X-Bz-Info-b2-cache-control"] = headers.cacheControl;
+		if (headers.contentEncoding) reqHeaders["X-Bz-Info-b2-content-encoding"] = headers.contentEncoding;
+		applyEncryptionHeaders(reqHeaders, headers.serverSideEncryption);
+		applyRetentionHeaders(reqHeaders, headers.fileRetention);
+		applyLegalHoldHeader(reqHeaders, headers.legalHold);
+		const response = await this.transport.send({
+			url: uploadUrl,
+			method: "POST",
+			headers: reqHeaders,
+			body,
+			...options?.signal !== void 0 ? { signal: options.signal } : {},
+			...options?.retry !== void 0 ? { retry: options.retry } : {}
+		});
+		try {
+			return normalizeFileVersionSha1(await response.json());
+		} catch (err) {
+			throw uploadResponseBodyError(err, options?.signal);
+		}
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-list-file-names | b2_list_file_names}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as an abort signal.
+	*
+	* @returns The list of file names and optional continuation token.
+	*/
+	async listFileNames(apiUrl, authToken, request, options) {
+		return normalizeFileVersionListSha1(await this.postJson(apiUrl, authToken, "b2_list_file_names", request, options));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-list-file-versions | b2_list_file_versions}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as an abort signal.
+	*
+	* @returns The list of file versions and optional continuation token.
+	*/
+	async listFileVersions(apiUrl, authToken, request, options) {
+		return normalizeFileVersionListSha1(await this.postJson(apiUrl, authToken, "b2_list_file_versions", request, options));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-get-file-info | b2_get_file_info}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The file version metadata.
+	*/
+	async getFileInfo(apiUrl, authToken, request) {
+		return normalizeFileVersionSha1(await this.postJson(apiUrl, authToken, "b2_get_file_info", request));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-hide-file | b2_hide_file}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as an abort signal.
+	*
+	* @returns The hidden file version metadata.
+	*/
+	async hideFile(apiUrl, authToken, request, options) {
+		return normalizeFileVersionSha1(await this.postJson(apiUrl, authToken, "b2_hide_file", request, options));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-delete-file-version | b2_delete_file_version}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as an abort signal.
+	*
+	* @returns The deleted file version identifier.
+	*/
+	async deleteFileVersion(apiUrl, authToken, request, options) {
+		return this.postJson(apiUrl, authToken, "b2_delete_file_version", request, options);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-copy-file | b2_copy_file}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as an abort signal.
+	*
+	* @returns The copied file version metadata.
+	*/
+	async copyFile(apiUrl, authToken, request, options) {
+		return normalizeFileVersionSha1(await this.postJson(apiUrl, authToken, "b2_copy_file", request, options));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-copy-part | b2_copy_part}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional abort and retry controls.
+	*
+	* @returns The copied part metadata.
+	*/
+	async copyPart(apiUrl, authToken, request, options) {
+		return this.postJson(apiUrl, authToken, "b2_copy_part", request, options);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-start-large-file | b2_start_large_file}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional abort and retry controls.
+	*
+	* @returns The started large file metadata with file ID.
+	*/
+	async startLargeFile(apiUrl, authToken, request, options) {
+		return this.postJson(apiUrl, authToken, "b2_start_large_file", request, options);
+	}
+	/**
+	* Implementation for both upload part URL request-control signatures.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param optionsOrSignal - Options bag or legacy abort signal.
+	* @param retry - Optional legacy per-request retry override.
+	*
+	* @returns The upload part URL and authorization token.
+	*/
+	async getUploadPartUrl(apiUrl, authToken, request, optionsOrSignal, retry) {
+		return this.postJson(apiUrl, authToken, "b2_get_upload_part_url", request, normalizeRawRequestOptions(optionsOrSignal, retry));
+	}
+	/**
+	* Implementation for both upload-part request-control signatures.
+	* @param uploadUrl - The upload endpoint URL.
+	* @param headers - The request headers including authorization and content metadata.
+	* @param body - The file data to upload.
+	* @param optionsOrSignal - Options bag or legacy abort signal.
+	* @param retry - Optional legacy per-request retry override.
+	*
+	* @returns The uploaded part metadata.
+	*/
+	async uploadPart(uploadUrl, headers, body, optionsOrSignal, retry) {
+		const options = normalizeRawRequestOptions(optionsOrSignal, retry);
+		const reqHeaders = {
+			Authorization: headers.authorization,
+			"X-Bz-Part-Number": String(headers.partNumber),
+			"Content-Length": String(headers.contentLength),
+			"X-Bz-Content-Sha1": headers.contentSha1
+		};
+		applyEncryptionHeaders(reqHeaders, headers.serverSideEncryption);
+		const response = await this.transport.send({
+			url: uploadUrl,
+			method: "POST",
+			headers: reqHeaders,
+			body,
+			...options?.signal !== void 0 ? { signal: options.signal } : {},
+			...options?.retry !== void 0 ? { retry: options.retry } : {}
+		});
+		try {
+			return await response.json();
+		} catch (err) {
+			throw uploadResponseBodyError(err, options?.signal);
+		}
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-finish-large-file | b2_finish_large_file}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional abort and retry controls.
+	*
+	* @returns The completed file version metadata.
+	*/
+	async finishLargeFile(apiUrl, authToken, request, options) {
+		const response = await this.transport.send({
+			url: `${apiUrl}/b2api/v3/b2_finish_large_file`,
+			method: "POST",
+			headers: {
+				Authorization: authToken,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(request),
+			...options?.signal !== void 0 ? { signal: options.signal } : {},
+			...options?.retry !== void 0 ? { retry: options.retry } : {}
+		});
+		let fileVersion;
+		try {
+			fileVersion = await response.json();
+		} catch (err) {
+			throw new FinishLargeFileResponseBodyError(err instanceof Error ? err.message : "Finish large file response body could not be read", {
+				cause: err,
+				fileId: request.fileId
+			});
+		}
+		return normalizeFileVersionSha1(fileVersion);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-cancel-large-file | b2_cancel_large_file}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as cancellation and retry overrides.
+	*
+	* @returns The cancelled large file metadata.
+	*/
+	async cancelLargeFile(apiUrl, authToken, request, options) {
+		return this.postJson(apiUrl, authToken, "b2_cancel_large_file", request, options);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-list-unfinished-large-files | b2_list_unfinished_large_files}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as cancellation and retry.
+	*
+	* @returns The list of unfinished large files and optional continuation token.
+	*/
+	async listUnfinishedLargeFiles(apiUrl, authToken, request, options) {
+		return this.postJson(apiUrl, authToken, "b2_list_unfinished_large_files", request, options);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-list-parts | b2_list_parts}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	* @param options - Optional request controls such as cancellation and retry.
+	*
+	* @returns The list of uploaded parts and optional continuation token.
+	*/
+	async listParts(apiUrl, authToken, request, options) {
+		return this.postJson(apiUrl, authToken, "b2_list_parts", request, options);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-download-file-by-id | b2_download_file_by_id}.
+	* @param downloadUrl - The B2 download base URL.
+	* @param authToken - The authorization token.
+	* @param fileId - The unique identifier of the file to download.
+	* @param options - Optional download parameters for range requests and cancellation.
+	*
+	* @returns The response headers, streaming body, and HTTP status code.
+	*/
+	async downloadFileById(downloadUrl, authToken, fileId, options) {
+		const headers = buildDownloadRequestHeaders(authToken, options);
+		const url = appendDownloadOverrides(`${downloadUrl}/b2api/v3/b2_download_file_by_id?fileId=${encodeURIComponent(fileId)}`, options);
+		const response = await this.transport.send({
+			url,
+			method: options?.method ?? "GET",
+			headers,
+			...options?.signal !== void 0 ? { signal: options.signal } : {}
+		});
+		return {
+			headers: response.headers,
+			body: response.body,
+			status: response.status
+		};
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-download-file-by-name | b2_download_file_by_name}.
+	* @param downloadUrl - The B2 download base URL.
+	* @param authToken - The authorization token.
+	* @param bucketName - The name of the bucket containing the file.
+	* @param fileName - The name of the file to download.
+	* @param options - Optional download parameters for range requests and cancellation.
+	*
+	* @returns The response headers, streaming body, and HTTP status code.
+	*/
+	async downloadFileByName(downloadUrl, authToken, bucketName, fileName, options) {
+		const headers = buildDownloadRequestHeaders(authToken, options);
+		const url = appendDownloadOverrides(`${downloadUrl}/file/${encodeURIComponent(bucketName)}/${encodeFileName(fileName)}`, options);
+		const response = await this.transport.send({
+			url,
+			method: options?.method ?? "GET",
+			headers,
+			...options?.signal !== void 0 ? { signal: options.signal } : {}
+		});
+		return {
+			headers: response.headers,
+			body: response.body,
+			status: response.status
+		};
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-get-download-authorization | b2_get_download_authorization}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The current session authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The download authorization token for the specified file prefix.
+	*/
+	async getDownloadAuthorization(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_get_download_authorization", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-create-key | b2_create_key}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The newly created application key with secret.
+	*/
+	async createKey(apiUrl, authToken, request) {
+		return normalizeKeyResponse(await this.postJson(apiUrl, authToken, "b2_create_key", normalizeCreateKeyRequest(request), void 0, "v4"));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-list-keys | b2_list_keys}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The list of application keys and optional continuation token.
+	*/
+	async listKeys(apiUrl, authToken, request) {
+		const response = await this.postJson(apiUrl, authToken, "b2_list_keys", request, void 0, "v4");
+		return {
+			...response,
+			keys: response.keys.map((key) => normalizeKeyResponse(key))
+		};
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-delete-key | b2_delete_key}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The deleted application key metadata.
+	*/
+	async deleteKey(apiUrl, authToken, request) {
+		return normalizeKeyResponse(await this.postJson(apiUrl, authToken, "b2_delete_key", request, void 0, "v4"));
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-update-file-retention | b2_update_file_retention}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The updated file retention settings.
+	*/
+	async updateFileRetention(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_update_file_retention", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-update-file-legal-hold | b2_update_file_legal_hold}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The updated file legal hold status.
+	*/
+	async updateFileLegalHold(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_update_file_legal_hold", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-get-bucket-notification-rules | b2_get_bucket_notification_rules}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The configured event notification rules for the specified bucket.
+	*/
+	async getBucketNotificationRules(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_get_bucket_notification_rules", request);
+	}
+	/**
+	* Calls {@link https://www.backblaze.com/apidocs/b2-set-bucket-notification-rules | b2_set_bucket_notification_rules}.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param request - The API request parameters.
+	*
+	* @returns The updated bucket notification rules.
+	*/
+	async setBucketNotificationRules(apiUrl, authToken, request) {
+		return this.postJson(apiUrl, authToken, "b2_set_bucket_notification_rules", request);
+	}
+	/**
+	* Sends a JSON POST request to the specified B2 API endpoint.
+	* @param apiUrl - The B2 API base URL.
+	* @param authToken - The authorization token.
+	* @param endpoint - The B2 API endpoint name.
+	* @param body - The JSON request body.
+	* @param options - Optional abort and per-request retry settings.
+	* @param apiVersion - B2 Native API version segment for this endpoint.
+	*
+	* @returns The parsed JSON response.
+	*/
+	async postJson(apiUrl, authToken, endpoint, body, options, apiVersion = "v3") {
+		return (await this.transport.send({
+			url: `${apiUrl}/b2api/${apiVersion}/${endpoint}`,
+			method: "POST",
+			headers: {
+				Authorization: authToken,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(body),
+			...options?.signal !== void 0 ? { signal: options.signal } : {},
+			...options?.retry !== void 0 ? { retry: options.retry } : {}
+		})).json();
+	}
+};
+/**
+* Applies server-side encryption headers to the request.
+* @param headers - The mutable headers object to populate.
+* @param encryption - The encryption settings, or undefined to skip.
+*/
 function applyEncryptionHeaders(headers, encryption) {
-  if (!encryption || encryption.mode === EncryptionMode.None) return;
-  if (encryption.mode === EncryptionMode.SseB2) {
-    headers["X-Bz-Server-Side-Encryption"] = EncryptionAlgorithm.Aes256;
-  } else if (encryption.mode === EncryptionMode.SseC) {
-    headers["X-Bz-Server-Side-Encryption-Customer-Algorithm"] = EncryptionAlgorithm.Aes256;
-    headers["X-Bz-Server-Side-Encryption-Customer-Key"] = encryption.customerKey;
-    headers["X-Bz-Server-Side-Encryption-Customer-Key-Md5"] = encryption.customerKeyMd5;
-  }
+	if (!encryption || encryption.mode === EncryptionMode.None) return;
+	if (encryption.mode === EncryptionMode.SseB2) headers["X-Bz-Server-Side-Encryption"] = EncryptionAlgorithm.Aes256;
+	else if (encryption.mode === EncryptionMode.SseC) {
+		headers["X-Bz-Server-Side-Encryption-Customer-Algorithm"] = EncryptionAlgorithm.Aes256;
+		headers["X-Bz-Server-Side-Encryption-Customer-Key"] = encryption.customerKey;
+		headers["X-Bz-Server-Side-Encryption-Customer-Key-Md5"] = encryption.customerKeyMd5;
+	}
 }
-const DOWNLOAD_OVERRIDE_PARAMS = [
-  "b2ContentDisposition",
-  "b2ContentLanguage",
-  "b2ContentEncoding",
-  "b2ContentType",
-  "b2CacheControl",
-  "b2Expires"
+var DOWNLOAD_OVERRIDE_PARAMS = [
+	"b2ContentDisposition",
+	"b2ContentLanguage",
+	"b2ContentEncoding",
+	"b2ContentType",
+	"b2CacheControl",
+	"b2Expires"
 ];
+/**
+* Builds the HTTP request headers for a download: Authorization, optional
+* Range, and optional SSE-C decryption headers.
+*
+* @param authToken - The B2 session authorization token.
+* @param options - Caller-supplied download options.
+*
+* @returns The header map to send with the request.
+*/
 function buildDownloadRequestHeaders(authToken, options) {
-  const headers = { Authorization: authToken };
-  if (options?.range) headers["Range"] = options.range;
-  if (options?.serverSideEncryption) {
-    applyEncryptionHeaders(headers, {
-      mode: EncryptionMode.SseC,
-      ...options.serverSideEncryption
-    });
-  }
-  return headers;
+	const headers = { Authorization: authToken };
+	if (options?.range) headers["Range"] = options.range;
+	if (options?.serverSideEncryption) applyEncryptionHeaders(headers, {
+		mode: EncryptionMode.SseC,
+		...options.serverSideEncryption
+	});
+	return headers;
 }
+/**
+* Appends the documented `b2Content*` response-header overrides to a download
+* URL as query-string parameters. B2 echoes the values into the response
+* headers so callers can control content type, disposition, and caching.
+*
+* @param url - The base download URL.
+* @param options - Caller-supplied download options.
+*
+* @returns The URL with any override parameters appended.
+*/
 function appendDownloadOverrides(url, options) {
-  if (!options) return url;
-  const params = [];
-  for (const key of DOWNLOAD_OVERRIDE_PARAMS) {
-    const value = options[key];
-    if (value !== void 0) {
-      params.push(`${key}=${encodeURIComponent(value)}`);
-    }
-  }
-  if (params.length === 0) return url;
-  const separator = url.includes("?") ? "&" : "?";
-  return `${url}${separator}${params.join("&")}`;
+	if (!options) return url;
+	const params = [];
+	for (const key of DOWNLOAD_OVERRIDE_PARAMS) {
+		const value = options[key];
+		if (value !== void 0) params.push(`${key}=${encodeURIComponent(value)}`);
+	}
+	if (params.length === 0) return url;
+	return `${url}${url.includes("?") ? "&" : "?"}${params.join("&")}`;
 }
+/**
+* Applies file retention headers to the request.
+* @param headers - The mutable headers object to populate.
+* @param retention - The retention settings, or undefined to skip.
+*/
 function applyRetentionHeaders(headers, retention) {
-  if (!retention) return;
-  if (retention.mode) {
-    headers["X-Bz-File-Retention-Mode"] = retention.mode;
-  }
-  if (retention.retainUntilTimestamp) {
-    headers["X-Bz-File-Retention-Retain-Until-Timestamp"] = String(retention.retainUntilTimestamp);
-  }
+	if (!retention) return;
+	if (retention.mode) headers["X-Bz-File-Retention-Mode"] = retention.mode;
+	if (retention.retainUntilTimestamp) headers["X-Bz-File-Retention-Retain-Until-Timestamp"] = String(retention.retainUntilTimestamp);
 }
+/**
+* Applies the legal hold header to the request.
+* @param headers - The mutable headers object to populate.
+* @param legalHold - The legal hold value, or undefined to skip.
+*/
 function applyLegalHoldHeader(headers, legalHold) {
-  if (!legalHold) return;
-  headers["X-Bz-File-Legal-Hold"] = legalHold;
+	if (!legalHold) return;
+	headers["X-Bz-File-Legal-Hold"] = legalHold;
 }
-export {
-  RawClient,
-  buildFileInfoHeaders,
-  decodeFileName,
-  encodeFileName,
-  parseFileInfoHeaders
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+export { RawClient, buildFileInfoHeaders, decodeFileName, encodeFileName, parseFileInfoHeaders };
+
+//# sourceMappingURL=index.js.map