@xylex-group/athena 2.8.0 → 2.8.2

package/dist/browser.cjs

@@ -802,7 +802,7 @@ var getCookieCache = async (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.8.0"
+  version: "2.8.2"
 };
 
 // src/sdk-version.ts
@@ -3398,7 +3398,12 @@ function createStorageFileModule(base, config = {}) {
           content_type: input.content_type ?? source.contentType,
           size_bytes: source.sizeBytes,
           public: input.public,
-          metadata: input.metadata
+          metadata: input.metadata,
+          server_side_encryption: input.server_side_encryption,
+          sse: input.sse,
+          ssekms_key_id: input.ssekms_key_id,
+          kms_key_id: input.kms_key_id,
+          bucket_key_enabled: input.bucket_key_enabled
         }
       };
     });
@@ -3409,10 +3414,17 @@ function createStorageFileModule(base, config = {}) {
     for (let index = 0; index < uploadRequests.length; index += 1) {
       const request = uploadRequests[index];
       const uploadUrl = uploadUrls[index];
-      const response = await putUploadBody(uploadUrl.upload.url, request.source, input, options, (progress) => {
-        aggregateLoaded[index] = progress.loaded;
-        input.onProgress?.(createProgressSnapshot("uploading", sources, index, progress.loaded, sum(aggregateLoaded)));
-      });
+      const response = await putUploadBody(
+        uploadUrl.upload.url,
+        uploadUrl.upload.headers ?? {},
+        request.source,
+        input,
+        options,
+        (progress) => {
+          aggregateLoaded[index] = progress.loaded;
+          input.onProgress?.(createProgressSnapshot("uploading", sources, index, progress.loaded, sum(aggregateLoaded)));
+        }
+      );
       uploaded.push({
         file: uploadUrl.file,
         upload: uploadUrl.upload,
@@ -3515,8 +3527,9 @@ function validateUploadConstraints(sources, input) {
     }
   }
 }
-async function putUploadBody(url, source, input, options, onProgress) {
-  const headers = new Headers(input.uploadHeaders);
+async function putUploadBody(url, uploadHeaders, source, input, options, onProgress) {
+  const headers = new Headers(uploadHeaders);
+  new Headers(input.uploadHeaders).forEach((value, key) => headers.set(key, value));
   if (source.contentType && !headers.has("Content-Type")) {
     headers.set("Content-Type", source.contentType);
   }
@@ -3841,6 +3854,23 @@ var storageSdkManifest = {
       responseEnvelope: "athena",
       responseType: "StorageFileMutationResponse"
     },
+    {
+      name: "postStorageFileVisibility",
+      method: "POST",
+      path: "/storage/files/{file_id}/visibility",
+      pathParams: ["file_id"],
+      requestType: "SetStorageFileVisibilityRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "setManyStorageFileVisibility",
+      method: "POST",
+      path: "/storage/files/visibility-many",
+      requestType: "SetManyStorageFileVisibilityRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationManyResponse"
+    },
     {
       name: "deleteStorageFolder",
       method: "POST",
@@ -3856,6 +3886,484 @@ var storageSdkManifest = {
       requestType: "MoveStorageFolderRequest",
       responseEnvelope: "athena",
       responseType: "StorageFolderMutationResponse"
+    },
+    {
+      name: "searchStorageFiles",
+      method: "POST",
+      path: "/storage/files/search",
+      requestType: "SearchStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageListFilesResponse"
+    },
+    {
+      name: "confirmStorageUpload",
+      method: "POST",
+      path: "/storage/files/{file_id}/confirm-upload",
+      pathParams: ["file_id"],
+      requestType: "ConfirmStorageUploadRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "uploadStorageFileBinary",
+      method: "PUT",
+      path: "/storage/files/{file_id}/upload",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse",
+      binary: true
+    },
+    {
+      name: "copyStorageFile",
+      method: "POST",
+      path: "/storage/files/{file_id}/copy",
+      pathParams: ["file_id"],
+      requestType: "CopyStorageFileRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "deleteManyStorageFiles",
+      method: "POST",
+      path: "/storage/files/delete-many",
+      requestType: "DeleteManyStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationManyResponse"
+    },
+    {
+      name: "updateManyStorageFiles",
+      method: "POST",
+      path: "/storage/files/update-many",
+      requestType: "UpdateManyStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationManyResponse"
+    },
+    {
+      name: "restoreStorageFile",
+      method: "POST",
+      path: "/storage/files/{file_id}/restore",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "purgeStorageFile",
+      method: "DELETE",
+      path: "/storage/files/{file_id}/purge",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "getStorageFilePublicUrl",
+      method: "GET",
+      path: "/storage/files/{file_id}/public-url",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageFileProxyUrl",
+      method: "GET",
+      path: "/storage/files/{file_id}/proxy-url",
+      pathParams: ["file_id"],
+      queryParams: ["purpose"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageFileVersions",
+      method: "GET",
+      path: "/storage/files/{file_id}/versions",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "restoreStorageFileVersion",
+      method: "POST",
+      path: "/storage/files/{file_id}/versions/{version_id}/restore",
+      pathParams: ["file_id", "version_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageFileVersion",
+      method: "DELETE",
+      path: "/storage/files/{file_id}/versions/{version_id}",
+      pathParams: ["file_id", "version_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageFileRetention",
+      method: "GET",
+      path: "/storage/files/{file_id}/retention",
+      pathParams: ["file_id"],
+      queryParams: ["version_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageFileRetention",
+      method: "POST",
+      path: "/storage/files/{file_id}/retention",
+      pathParams: ["file_id"],
+      requestType: "StorageFileRetentionRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageFolders",
+      method: "POST",
+      path: "/storage/folders/list",
+      requestType: "ListStorageFoldersRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "treeStorageFolders",
+      method: "POST",
+      path: "/storage/folders/tree",
+      requestType: "TreeStorageFoldersRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStoragePermissions",
+      method: "POST",
+      path: "/storage/permissions/list",
+      requestType: "StoragePermissionListRequest",
+      responseEnvelope: "athena",
+      responseType: "StoragePermissionListResponse"
+    },
+    {
+      name: "grantStoragePermission",
+      method: "POST",
+      path: "/storage/permissions/grant",
+      requestType: "StoragePermissionGrantRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "revokeStoragePermission",
+      method: "POST",
+      path: "/storage/permissions/revoke",
+      requestType: "StoragePermissionRevokeRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "checkStoragePermission",
+      method: "POST",
+      path: "/storage/permissions/check",
+      requestType: "StoragePermissionCheckRequest",
+      responseEnvelope: "athena",
+      responseType: "StoragePermissionCheckResponse"
+    },
+    {
+      name: "listStorageObjects",
+      method: "POST",
+      path: "/storage/objects",
+      requestType: "StorageListObjectsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "headStorageObject",
+      method: "POST",
+      path: "/storage/objects/head",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "existsStorageObject",
+      method: "POST",
+      path: "/storage/objects/exists",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "validateStorageObject",
+      method: "POST",
+      path: "/storage/objects/validate",
+      requestType: "StorageObjectValidateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "updateStorageObject",
+      method: "POST",
+      path: "/storage/objects/update",
+      requestType: "StorageUpdateObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "copyStorageObject",
+      method: "POST",
+      path: "/storage/objects/copy",
+      requestType: "StorageObjectCopyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageObjectUrl",
+      method: "POST",
+      path: "/storage/objects/url",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageObjectPublicUrl",
+      method: "POST",
+      path: "/storage/objects/public-url",
+      requestType: "StorageObjectPublicUrlRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageObject",
+      method: "POST",
+      path: "/storage/objects/delete",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageObjectUploadUrl",
+      method: "POST",
+      path: "/storage/objects/upload-url",
+      requestType: "StoragePresignUploadRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageObjectPostPolicy",
+      method: "POST",
+      path: "/storage/objects/post-policy",
+      requestType: "StorageSignedPostPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageObjectVersions",
+      method: "POST",
+      path: "/storage/objects/versions",
+      requestType: "StorageObjectVersionListRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "restoreStorageObjectVersion",
+      method: "POST",
+      path: "/storage/objects/versions/restore",
+      requestType: "StorageObjectVersionMutationRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageObjectVersion",
+      method: "POST",
+      path: "/storage/objects/versions/delete",
+      requestType: "StorageObjectVersionMutationRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageObjectFolder",
+      method: "POST",
+      path: "/storage/objects/folder",
+      requestType: "StorageObjectFolderCreateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageObjectFolder",
+      method: "POST",
+      path: "/storage/objects/folder/delete",
+      requestType: "StorageObjectFolderDeleteRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "renameStorageObjectFolder",
+      method: "POST",
+      path: "/storage/objects/folder/rename",
+      requestType: "StorageObjectFolderRenameRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageBuckets",
+      method: "POST",
+      path: "/storage/buckets/list",
+      requestType: "Omit<StorageObjectBaseRequest, 'bucket'>",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageBucket",
+      method: "POST",
+      path: "/storage/buckets/create",
+      requestType: "StorageObjectBaseRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucket",
+      method: "POST",
+      path: "/storage/buckets/delete",
+      requestType: "StorageObjectBaseRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketLifecycle",
+      method: "POST",
+      path: "/storage/buckets/lifecycle",
+      requestType: "StorageBucketLifecycleRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketLifecycle",
+      method: "POST",
+      path: "/storage/buckets/lifecycle/set",
+      requestType: "StorageSetBucketLifecycleRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketLifecycle",
+      method: "POST",
+      path: "/storage/buckets/lifecycle/delete",
+      requestType: "StorageBucketLifecycleRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy",
+      requestType: "StorageBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy/set",
+      requestType: "StorageSetBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy/delete",
+      requestType: "StorageBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access",
+      requestType: "StoragePublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access/set",
+      requestType: "StorageSetPublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access/delete",
+      requestType: "StoragePublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors",
+      requestType: "StorageBucketCorsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors/set",
+      requestType: "StorageSetBucketCorsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors/delete",
+      requestType: "StorageBucketCorsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/create",
+      requestType: "StorageMultipartCreateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "signStorageMultipartPart",
+      method: "POST",
+      path: "/storage/multipart/sign-part",
+      requestType: "StorageMultipartSignPartRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "completeStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/complete",
+      requestType: "StorageMultipartCompleteRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "abortStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/abort",
+      requestType: "StorageMultipartAbortRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageMultipartParts",
+      method: "POST",
+      path: "/storage/multipart/list-parts",
+      requestType: "StorageMultipartListPartsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageAuditEvents",
+      method: "POST",
+      path: "/storage/audit/list",
+      requestType: "StorageAuditQueryRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageAuditListResponse"
     }
   ]
 };
@@ -4316,7 +4824,7 @@ async function putPresignedUploadBody(uploadUrl, uploadHeaders, body, options) {
   return fetch(uploadUrl, init);
 }
 function attachManagedUpload(upload) {
-  const headers = {};
+  const headers = { ...upload.headers ?? {} };
   return {
     ...upload,
     method: "PUT",
@@ -4362,7 +4870,12 @@ function normalizeUploadUrlRequest(input) {
     file_id: input.file_id ?? input.fileId,
     public: input.public,
     visibility: input.visibility,
-    metadata: input.metadata
+    metadata: input.metadata,
+    server_side_encryption: input.server_side_encryption,
+    sse: input.sse,
+    ssekms_key_id: input.ssekms_key_id,
+    kms_key_id: input.kms_key_id,
+    bucket_key_enabled: input.bucket_key_enabled
   };
 }
 async function callStorageUploadBinaryEndpoint(gateway, endpoint, body, options, runtimeOptions) {
@@ -4513,6 +5026,12 @@ function createStorageModule(gateway, runtimeOptions) {
     options,
     resolvedRuntimeOptions
   );
+  const callStorageFileVisibility = (fileId, method, input, options) => callAthena2(
+    withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId),
+    method,
+    input,
+    options
+  );
   const base = {
     listStorageCatalogs(options) {
       return callRaw("/storage/catalogs", "GET", void 0, options);
@@ -4562,7 +5081,7 @@ function createStorageModule(gateway, runtimeOptions) {
       return callAthena2(withPathParam("/storage/files/{file_id}", "file_id", fileId), "DELETE", void 0, options);
     },
     setStorageFileVisibility(fileId, input, options) {
-      return callAthena2(withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId), "PATCH", input, options);
+      return callStorageFileVisibility(fileId, "PATCH", input, options);
     },
     deleteStorageFolder(input, options) {
       return callAthena2("/storage/folders/delete", "POST", input, options);
@@ -4634,13 +5153,62 @@ function createStorageModule(gateway, runtimeOptions) {
     publicUrl(fileId, options) {
       return callAthena2(withPathParam("/storage/files/{file_id}/public-url", "file_id", fileId), "GET", void 0, options);
     },
+    proxyUrl(fileId, query, options) {
+      const path = appendQuery(
+        withPathParam("/storage/files/{file_id}/proxy-url", "file_id", fileId),
+        query
+      );
+      return callAthena2(path, "GET", void 0, options);
+    },
     proxy(fileId, query, options) {
       return base.getStorageFileProxy(fileId, query, options);
     },
-    visibility: {
+    versions(fileId, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/versions", "file_id", fileId), "GET", void 0, options);
+    },
+    restoreVersion(fileId, versionId, options) {
+      return callAthena2(
+        withPathParam(
+          withPathParam("/storage/files/{file_id}/versions/{version_id}/restore", "file_id", fileId),
+          "version_id",
+          versionId
+        ),
+        "POST",
+        {},
+        options
+      );
+    },
+    deleteVersion(fileId, versionId, options) {
+      return callAthena2(
+        withPathParam(
+          withPathParam("/storage/files/{file_id}/versions/{version_id}", "file_id", fileId),
+          "version_id",
+          versionId
+        ),
+        "DELETE",
+        void 0,
+        options
+      );
+    },
+    retention: {
+      get(fileId, query, options) {
+        const path = appendQuery(
+          withPathParam("/storage/files/{file_id}/retention", "file_id", fileId),
+          query
+        );
+        return callAthena2(path, "GET", void 0, options);
+      },
       set(fileId, input, options) {
+        return callAthena2(withPathParam("/storage/files/{file_id}/retention", "file_id", fileId), "POST", input, options);
+      }
+    },
+    visibility: {
+      update(fileId, input, options) {
         return base.setStorageFileVisibility(fileId, input, options);
       },
+      set(fileId, input, options) {
+        return callStorageFileVisibility(fileId, "POST", input, options);
+      },
       setMany(input, options) {
         return callAthena2("/storage/files/visibility-many", "POST", input, options);
       }
@@ -4735,6 +5303,18 @@ function createStorageModule(gateway, runtimeOptions) {
     uploadUrl(input, options) {
       return callAthena2("/storage/objects/upload-url", "POST", input, options);
     },
+    versions(input, options) {
+      return callAthena2("/storage/objects/versions", "POST", input, options);
+    },
+    restoreVersion(input, options) {
+      return callAthena2("/storage/objects/versions/restore", "POST", input, options);
+    },
+    deleteVersion(input, options) {
+      return callAthena2("/storage/objects/versions/delete", "POST", input, options);
+    },
+    postPolicy(input, options) {
+      return callAthena2("/storage/objects/post-policy", "POST", input, options);
+    },
     folder: objectFolder
   };
   const bucket = {
@@ -4747,6 +5327,39 @@ function createStorageModule(gateway, runtimeOptions) {
     delete(input, options) {
       return callAthena2("/storage/buckets/delete", "POST", input, options);
     },
+    lifecycle: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/lifecycle", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/lifecycle/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/lifecycle/delete", "POST", input, options);
+      }
+    },
+    policy: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/policy", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/policy/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/policy/delete", "POST", input, options);
+      }
+    },
+    publicAccess: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/public-access", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/public-access/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/public-access/delete", "POST", input, options);
+      }
+    },
     cors: {
       get(input, options) {
         return callAthena2("/storage/buckets/cors", "POST", input, options);
@@ -7513,21 +8126,54 @@ function resolveServiceUrls(config) {
     storageUrl: resolveServiceUrlOverride(config.storage?.url, "Athena storage base URL") ?? resolveServiceUrlOverride(config.storageUrl, "Athena storage base URL") ?? (baseUrl ? appendServicePath(baseUrl, "storage") : void 0)
   };
 }
+function resolveOptionalClientName(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : void 0;
+}
+function resolveRequiredClientApiKey(value) {
+  if (value === void 0 || value === null) {
+    throw new Error(
+      "Athena API key is required. Pass createClient(url, key) with a real API key, or set key in the config object."
+    );
+  }
+  const normalizedValue = value.trim();
+  if (!normalizedValue) {
+    throw new Error(
+      "Athena API key is required. Pass createClient(url, key) with a real API key, or set key in the config object."
+    );
+  }
+  return normalizedValue;
+}
 function normalizeAuthClientConfig(auth, defaultBaseUrl) {
   if (!auth && defaultBaseUrl === void 0) {
     return void 0;
   }
-  const { url, ...rest } = auth ?? {};
+  const {
+    url,
+    baseUrl,
+    apiKey,
+    bearerToken,
+    ...rest
+  } = auth ?? {};
   const normalized = {
     ...rest
   };
   const resolvedBaseUrl = resolveClientServiceBaseUrl(
-    url ?? rest.baseUrl ?? defaultBaseUrl,
+    url ?? baseUrl ?? defaultBaseUrl,
     "Athena auth base URL"
   );
   if (resolvedBaseUrl !== void 0) {
     normalized.baseUrl = resolvedBaseUrl;
   }
+  if (typeof apiKey === "string") {
+    normalized.apiKey = apiKey;
+  }
+  if (typeof bearerToken === "string") {
+    normalized.bearerToken = bearerToken;
+  }
   return normalized;
 }
 function resolveCreateClientConfig(config) {
@@ -7539,8 +8185,8 @@ function resolveCreateClientConfig(config) {
   }
   return {
     baseUrl: resolvedUrls.dbUrl,
-    apiKey: config.key,
-    client: config.client,
+    apiKey: resolveRequiredClientApiKey(config.key),
+    client: resolveOptionalClientName(config.client),
     backend: toBackendConfig(config.backend),
     headers: config.headers,
     auth: config.auth,
@@ -7663,7 +8309,7 @@ var AthenaClient = class {
   }
 };
 function createClient(configOrUrl, apiKey, options) {
-  if (typeof configOrUrl === "string") {
+  if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
     return createClientFromConfig(resolveCreateClientConfig({
       url: configOrUrl,
       key: apiKey ?? "",