@scality/data-browser-library 1.0.0-preview.8 → 1.0.1

package/dist/hooks/__tests__/useISVBucketDetection.test.js

@@ -0,0 +1,188 @@
+import { renderHook } from "@testing-library/react";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { BUCKET_TAG_APPLICATION, BUCKET_TAG_VEEAM_APPLICATION, COMMVAULT_APPLICATION, VEEAM_BACKUP_REPLICATION, VEEAM_OFFICE_365, VEEAM_OFFICE_365_V8, VEEAM_VBO_APPLICATION } from "../../utils/constants.js";
+import { useGetBucketTagging } from "../bucketConfiguration.js";
+import { useFeatures } from "../useFeatures.js";
+import { useISVBucketStatus } from "../useISVBucketDetection.js";
+jest.mock('../bucketConfiguration');
+jest.mock('../useFeatures');
+const mockUseGetBucketTagging = useGetBucketTagging;
+const mockUseFeatures = useFeatures;
+describe('useISVBucketStatus', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUseFeatures.mockReturnValue(true);
+    });
+    it('should return false for all flags when ISV feature is disabled', ()=>{
+        mockUseFeatures.mockReturnValue(false);
+        mockUseGetBucketTagging.mockReturnValue({
+            data: void 0,
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(false);
+        expect(result.current.isCommvaultBucket).toBe(false);
+        expect(result.current.isISVManaged).toBe(false);
+        expect(result.current.isvApplication).toBeUndefined();
+        expect(result.current.isLoading).toBe(false);
+    });
+    it('should detect Veeam Backup & Replication bucket', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_VEEAM_APPLICATION,
+                        Value: VEEAM_BACKUP_REPLICATION
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isCommvaultBucket).toBe(false);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe('Veeam');
+    });
+    it('should detect Veeam Office 365 v6/v7 bucket', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_VEEAM_APPLICATION,
+                        Value: VEEAM_OFFICE_365
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe('Veeam');
+    });
+    it('should detect Veeam Office 365 v8+ bucket', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_VEEAM_APPLICATION,
+                        Value: VEEAM_OFFICE_365_V8
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe('Veeam');
+    });
+    it('should detect ISV bucket tagged as Veeam Backup & Replication', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_APPLICATION,
+                        Value: VEEAM_BACKUP_REPLICATION
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe('Veeam');
+    });
+    it('should detect ISV bucket tagged as Veeam VBO', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_APPLICATION,
+                        Value: VEEAM_VBO_APPLICATION
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe('Veeam');
+    });
+    it('should detect Commvault bucket', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_APPLICATION,
+                        Value: COMMVAULT_APPLICATION
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(false);
+        expect(result.current.isCommvaultBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe('Commvault');
+    });
+    it('should return false for non-ISV bucket', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: 'SomeOtherTag',
+                        Value: 'SomeValue'
+                    }
+                ]
+            },
+            status: 'success'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(false);
+        expect(result.current.isCommvaultBucket).toBe(false);
+        expect(result.current.isISVManaged).toBe(false);
+        expect(result.current.isvApplication).toBeUndefined();
+    });
+    it('should return loading state when fetching bucket tags', ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: void 0,
+            status: 'pending'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isLoading).toBe(true);
+    });
+    it('should not be loading when ISV feature is disabled', ()=>{
+        mockUseFeatures.mockReturnValue(false);
+        mockUseGetBucketTagging.mockReturnValue({
+            data: void 0,
+            status: 'pending'
+        });
+        const { result } = renderHook(()=>useISVBucketStatus('test-bucket'), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isLoading).toBe(false);
+    });
+});

package/dist/hooks/__tests__/useIsBucketEmpty.test.js

@@ -1,24 +1,24 @@
-import { useIsBucketEmpty } from "../useIsBucketEmpty.js";
-import { useListObjects } from "../objectOperations.js";
 import { renderHookWithWrapper } from "../../test/testUtils.js";
-jest.mock("../objectOperations");
+import { useListObjects } from "../objectOperations.js";
+import { useIsBucketEmpty } from "../useIsBucketEmpty.js";
+jest.mock('../objectOperations');
 const mockUseListObjects = jest.mocked(useListObjects);
-describe("useIsBucketEmpty", ()=>{
+describe('useIsBucketEmpty', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
     });
-    it("returns loading state when checking bucket", ()=>{
+    it('returns loading state when checking bucket', ()=>{
         mockUseListObjects.mockReturnValue({
             data: void 0,
-            status: "pending",
+            status: 'pending',
             error: null
         });
-        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty('test-bucket'));
         expect(result.current.isEmpty).toBe(null);
         expect(result.current.isLoading).toBe(true);
         expect(result.current.error).toBe(null);
     });
-    it("returns true when bucket is empty", ()=>{
+    it('returns true when bucket is empty', ()=>{
         mockUseListObjects.mockReturnValue({
             data: {
                 pages: [
@@ -28,35 +28,35 @@ describe("useIsBucketEmpty", ()=>{
                     }
                 ]
             },
-            status: "success",
+            status: 'success',
             error: null
         });
-        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty('test-bucket'));
         expect(result.current.isEmpty).toBe(true);
         expect(result.current.isLoading).toBe(false);
     });
-    it("returns false when bucket has objects", ()=>{
+    it('returns false when bucket has objects', ()=>{
         mockUseListObjects.mockReturnValue({
             data: {
                 pages: [
                     {
                         Contents: [
                             {
-                                Key: "file.txt"
+                                Key: 'file.txt'
                             }
                         ],
                         CommonPrefixes: []
                     }
                 ]
             },
-            status: "success",
+            status: 'success',
             error: null
         });
-        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty('test-bucket'));
         expect(result.current.isEmpty).toBe(false);
         expect(result.current.isLoading).toBe(false);
     });
-    it("returns false when bucket has folders", ()=>{
+    it('returns false when bucket has folders', ()=>{
         mockUseListObjects.mockReturnValue({
             data: {
                 pages: [
@@ -64,32 +64,32 @@ describe("useIsBucketEmpty", ()=>{
                         Contents: [],
                         CommonPrefixes: [
                             {
-                                Prefix: "folder/"
+                                Prefix: 'folder/'
                             }
                         ]
                     }
                 ]
             },
-            status: "success",
+            status: 'success',
             error: null
         });
-        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty('test-bucket'));
         expect(result.current.isEmpty).toBe(false);
         expect(result.current.isLoading).toBe(false);
     });
-    it("handles error state", ()=>{
-        const testError = new Error("Access denied");
+    it('handles error state', ()=>{
+        const testError = new Error('Access denied');
         mockUseListObjects.mockReturnValue({
             data: void 0,
-            status: "error",
+            status: 'error',
             error: testError
         });
-        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty('test-bucket'));
         expect(result.current.isEmpty).toBe(null);
         expect(result.current.isLoading).toBe(false);
         expect(result.current.error).toBe(testError);
     });
-    it("ignores invalid objects and prefixes", ()=>{
+    it('ignores invalid objects and prefixes', ()=>{
         mockUseListObjects.mockReturnValue({
             data: {
                 pages: [
@@ -99,7 +99,7 @@ describe("useIsBucketEmpty", ()=>{
                                 Key: void 0
                             },
                             {
-                                Key: ""
+                                Key: ''
                             }
                         ],
                         CommonPrefixes: [
@@ -107,16 +107,16 @@ describe("useIsBucketEmpty", ()=>{
                                 Prefix: null
                             },
                             {
-                                Prefix: ""
+                                Prefix: ''
                             }
                         ]
                     }
                 ]
             },
-            status: "success",
+            status: 'success',
             error: null
         });
-        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty('test-bucket'));
         expect(result.current.isEmpty).toBe(true);
     });
 });

package/dist/hooks/__tests__/useLoginMutation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/__tests__/useLoginMutation.test.js

@@ -0,0 +1,194 @@
+import { waitFor } from "@testing-library/react";
+import { mockS3Client, renderHookWithWrapper, setupCommonMocks } from "../../test/testUtils.js";
+import { useLoginMutation } from "../loginOperations.js";
+jest.mock('@aws-sdk/client-s3');
+describe('useLoginMutation', ()=>{
+    beforeEach(()=>{
+        setupCommonMocks();
+        jest.clearAllMocks();
+    });
+    it('calls onSuccess when login is successful', async ()=>{
+        const onSuccess = jest.fn();
+        mockS3Client.send.mockResolvedValue({
+            Buckets: []
+        });
+        const { result } = renderHookWithWrapper(()=>useLoginMutation({
+                onSuccess
+            }));
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(onSuccess).toHaveBeenCalled();
+        expect(result.current.data).toEqual({
+            authenticated: true,
+            config
+        });
+    });
+    it('calls onError when user lacks ListBuckets permission', async ()=>{
+        const onError = jest.fn();
+        class AccessDeniedError extends Error {
+            constructor(message){
+                super(message);
+                this.name = 'AccessDenied';
+            }
+            $metadata = {
+                httpStatusCode: 403
+            };
+        }
+        const accessDeniedError = new AccessDeniedError('Access Denied');
+        mockS3Client.send.mockRejectedValue(accessDeniedError);
+        const { result } = renderHookWithWrapper(()=>useLoginMutation({
+                onError
+            }));
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(onError).toHaveBeenCalled();
+        expect(result.current.error?.name).toBe('AccessDenied');
+    });
+    it('calls onError for other errors', async ()=>{
+        const onError = jest.fn();
+        class InvalidAccessKeyIdError extends Error {
+            constructor(message){
+                super(message);
+                this.name = 'InvalidAccessKeyId';
+            }
+            $metadata = {
+                httpStatusCode: 403
+            };
+        }
+        const invalidCredentialsError = new InvalidAccessKeyIdError('The access key ID you provided does not exist');
+        mockS3Client.send.mockRejectedValue(invalidCredentialsError);
+        const { result } = renderHookWithWrapper(()=>useLoginMutation({
+                onError
+            }));
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'invalid-key',
+                secretAccessKey: 'invalid-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(onError).toHaveBeenCalled();
+        expect(result.current.error?.name).toBe('InvalidAccessKeyId');
+    });
+    it('works without onError callback', async ()=>{
+        class AccessDeniedError extends Error {
+            constructor(message){
+                super(message);
+                this.name = 'AccessDenied';
+            }
+            $metadata = {
+                httpStatusCode: 403
+            };
+        }
+        const accessDeniedError = new AccessDeniedError('Access Denied');
+        mockS3Client.send.mockRejectedValue(accessDeniedError);
+        const { result } = renderHookWithWrapper(()=>useLoginMutation());
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error?.name).toBe('AccessDenied');
+    });
+    it('returns authenticated config on successful login', async ()=>{
+        mockS3Client.send.mockResolvedValue({
+            Buckets: []
+        });
+        const { result } = renderHookWithWrapper(()=>useLoginMutation());
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual({
+            authenticated: true,
+            config
+        });
+    });
+    it('handles network errors appropriately', async ()=>{
+        const onError = jest.fn();
+        const networkError = new Error('Network request failed');
+        mockS3Client.send.mockRejectedValue(networkError);
+        const { result } = renderHookWithWrapper(()=>useLoginMutation({
+                onError
+            }));
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(onError).toHaveBeenCalled();
+    });
+    it('validates credentials by calling ListBuckets command', async ()=>{
+        mockS3Client.send.mockResolvedValue({
+            Buckets: []
+        });
+        const { result } = renderHookWithWrapper(()=>useLoginMutation());
+        const config = {
+            endpoint: 'https://s3.amazonaws.com',
+            region: 'us-east-1',
+            forcePathStyle: true,
+            credentials: {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret'
+            }
+        };
+        result.current.mutate(config);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(mockS3Client.send).toHaveBeenCalled();
+    });
+});

package/dist/hooks/bucketConfiguration.d.ts

@@ -4,7 +4,7 @@
  * This file contains hooks for managing bucket configuration settings
  * like ACL, policies, versioning, CORS, lifecycle, etc.
  */
-import { GetBucketAclCommandInput, GetBucketAclCommandOutput, PutBucketAclCommandInput, PutBucketAclCommandOutput, GetBucketPolicyCommandInput, GetBucketPolicyCommandOutput, PutBucketPolicyCommandInput, PutBucketPolicyCommandOutput, DeleteBucketPolicyCommandInput, DeleteBucketPolicyCommandOutput, GetBucketVersioningCommandInput, GetBucketVersioningCommandOutput, PutBucketVersioningCommandInput, PutBucketVersioningCommandOutput, GetBucketCorsCommandInput, GetBucketCorsCommandOutput, PutBucketCorsCommandInput, PutBucketCorsCommandOutput, DeleteBucketCorsCommandInput, DeleteBucketCorsCommandOutput, GetBucketLifecycleConfigurationCommandInput, GetBucketLifecycleConfigurationCommandOutput, PutBucketLifecycleConfigurationCommandInput, PutBucketLifecycleConfigurationCommandOutput, DeleteBucketLifecycleCommandInput, DeleteBucketLifecycleCommandOutput, GetBucketNotificationConfigurationCommandInput, GetBucketNotificationConfigurationCommandOutput, PutBucketNotificationConfigurationCommandInput, PutBucketNotificationConfigurationCommandOutput, GetBucketEncryptionCommandInput, GetBucketEncryptionCommandOutput, PutBucketEncryptionCommandInput, PutBucketEncryptionCommandOutput, GetBucketTaggingCommandInput, GetBucketTaggingCommandOutput, PutBucketTaggingCommandInput, PutBucketTaggingCommandOutput, DeleteBucketTaggingCommandInput, DeleteBucketTaggingCommandOutput, GetObjectLockConfigurationCommandInput, GetObjectLockConfigurationCommandOutput, PutObjectLockConfigurationCommandInput, PutObjectLockConfigurationCommandOutput, GetBucketReplicationCommandInput, GetBucketReplicationCommandOutput, PutBucketReplicationCommandInput, PutBucketReplicationCommandOutput, DeleteBucketReplicationCommandInput, DeleteBucketReplicationCommandOutput } from "@aws-sdk/client-s3";
+import { type DeleteBucketCorsCommandInput, type DeleteBucketCorsCommandOutput, type DeleteBucketLifecycleCommandInput, type DeleteBucketLifecycleCommandOutput, type DeleteBucketPolicyCommandInput, type DeleteBucketPolicyCommandOutput, type DeleteBucketReplicationCommandInput, type DeleteBucketReplicationCommandOutput, type DeleteBucketTaggingCommandInput, type DeleteBucketTaggingCommandOutput, type GetBucketAclCommandInput, type GetBucketAclCommandOutput, type GetBucketCorsCommandInput, type GetBucketCorsCommandOutput, type GetBucketEncryptionCommandInput, type GetBucketEncryptionCommandOutput, type GetBucketLifecycleConfigurationCommandInput, type GetBucketLifecycleConfigurationCommandOutput, type GetBucketNotificationConfigurationCommandInput, type GetBucketNotificationConfigurationCommandOutput, type GetBucketPolicyCommandInput, type GetBucketPolicyCommandOutput, type GetBucketReplicationCommandInput, type GetBucketReplicationCommandOutput, type GetBucketTaggingCommandInput, type GetBucketTaggingCommandOutput, type GetBucketVersioningCommandInput, type GetBucketVersioningCommandOutput, type GetObjectLockConfigurationCommandInput, type GetObjectLockConfigurationCommandOutput, type GetPublicAccessBlockCommandInput, type GetPublicAccessBlockCommandOutput, type PutBucketAclCommandInput, type PutBucketAclCommandOutput, type PutBucketCorsCommandInput, type PutBucketCorsCommandOutput, type PutBucketEncryptionCommandInput, type PutBucketEncryptionCommandOutput, type PutBucketLifecycleConfigurationCommandInput, type PutBucketLifecycleConfigurationCommandOutput, type PutBucketNotificationConfigurationCommandInput, type PutBucketNotificationConfigurationCommandOutput, type PutBucketPolicyCommandInput, type PutBucketPolicyCommandOutput, type PutBucketReplicationCommandInput, type PutBucketReplicationCommandOutput, type PutBucketTaggingCommandInput, type PutBucketTaggingCommandOutput, type PutBucketVersioningCommandInput, type PutBucketVersioningCommandOutput, type PutObjectLockConfigurationCommandInput, type PutObjectLockConfigurationCommandOutput } from '@aws-sdk/client-s3';
 /**
  * Hook for retrieving S3 bucket access control list (ACL) settings
  *
@@ -166,3 +166,10 @@ export declare const useSetBucketReplication: (options?: Omit<import("@tanstack/
  * been replicated remain in the destination bucket.
  */
 export declare const useDeleteBucketReplication: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteBucketReplicationCommandOutput, import("..").EnhancedS3Error, DeleteBucketReplicationCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteBucketReplicationCommandOutput, import("..").EnhancedS3Error, DeleteBucketReplicationCommandInput>;
+/**
+ * Hook for retrieving S3 bucket public access block configuration
+ *
+ * Fetches the public access block configuration for an S3 bucket.
+ * This configuration determines whether public access is blocked at the bucket level.
+ */
+export declare const useGetPublicAccessBlock: (params?: GetPublicAccessBlockCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetPublicAccessBlockCommandOutput, import("..").EnhancedS3Error, GetPublicAccessBlockCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetPublicAccessBlockCommandOutput, import("..").EnhancedS3Error>;