@scality/data-browser-library 1.0.0-preview.11

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

@@ -0,0 +1,188 @@
+import { renderHook } from "@testing-library/react";
+import { useISVBucketStatus } from "../useISVBucketDetection.js";
+import { useGetBucketTagging } from "../bucketConfiguration.js";
+import { useFeatures } from "../../utils/useFeatures.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 { createTestWrapper } from "../../test/testUtils.js";
+jest.mock("../bucketConfiguration");
+jest.mock("../../utils/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.d.ts

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

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

@@ -0,0 +1,122 @@
+import { useIsBucketEmpty } from "../useIsBucketEmpty.js";
+import { useListObjects } from "../objectOperations.js";
+import { renderHookWithWrapper } from "../../test/testUtils.js";
+jest.mock("../objectOperations");
+const mockUseListObjects = jest.mocked(useListObjects);
+describe("useIsBucketEmpty", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+    });
+    it("returns loading state when checking bucket", ()=>{
+        mockUseListObjects.mockReturnValue({
+            data: void 0,
+            status: "pending",
+            error: null
+        });
+        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", ()=>{
+        mockUseListObjects.mockReturnValue({
+            data: {
+                pages: [
+                    {
+                        Contents: [],
+                        CommonPrefixes: []
+                    }
+                ]
+            },
+            status: "success",
+            error: null
+        });
+        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", ()=>{
+        mockUseListObjects.mockReturnValue({
+            data: {
+                pages: [
+                    {
+                        Contents: [
+                            {
+                                Key: "file.txt"
+                            }
+                        ],
+                        CommonPrefixes: []
+                    }
+                ]
+            },
+            status: "success",
+            error: null
+        });
+        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", ()=>{
+        mockUseListObjects.mockReturnValue({
+            data: {
+                pages: [
+                    {
+                        Contents: [],
+                        CommonPrefixes: [
+                            {
+                                Prefix: "folder/"
+                            }
+                        ]
+                    }
+                ]
+            },
+            status: "success",
+            error: null
+        });
+        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");
+        mockUseListObjects.mockReturnValue({
+            data: void 0,
+            status: "error",
+            error: testError
+        });
+        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", ()=>{
+        mockUseListObjects.mockReturnValue({
+            data: {
+                pages: [
+                    {
+                        Contents: [
+                            {
+                                Key: void 0
+                            },
+                            {
+                                Key: ""
+                            }
+                        ],
+                        CommonPrefixes: [
+                            {
+                                Prefix: null
+                            },
+                            {
+                                Prefix: ""
+                            }
+                        ]
+                    }
+                ]
+            },
+            status: "success",
+            error: null
+        });
+        const { result } = renderHookWithWrapper(()=>useIsBucketEmpty("test-bucket"));
+        expect(result.current.isEmpty).toBe(true);
+    });
+});

package/dist/hooks/bucketConfiguration.d.ts

@@ -0,0 +1,168 @@
+/**
+ * S3 Bucket Configuration Operations
+ *
+ * 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";
+/**
+ * Hook for retrieving S3 bucket access control list (ACL) settings
+ *
+ * Fetches the access control list of an S3 bucket, which defines permissions
+ * for different AWS accounts or predefined groups.
+ */
+export declare const useGetBucketAcl: (params?: GetBucketAclCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketAclCommandOutput, import("..").EnhancedS3Error, GetBucketAclCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketAclCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket ACL (Access Control List)
+ *
+ * Updates the access control list for an S3 bucket. The ACL defines which AWS
+ * accounts or groups are granted access and the type of access.
+ */
+export declare const useSetBucketAcl: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketAclCommandOutput, import("..").EnhancedS3Error, PutBucketAclCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketAclCommandOutput, import("..").EnhancedS3Error, PutBucketAclCommandInput>;
+/**
+ * Hook for retrieving S3 bucket policy
+ *
+ * Fetches the bucket policy for an S3 bucket as a JSON string. The bucket policy
+ * defines permissions for accessing the bucket and its objects.
+ */
+export declare const useGetBucketPolicy: (params?: GetBucketPolicyCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketPolicyCommandOutput, import("..").EnhancedS3Error, GetBucketPolicyCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketPolicyCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket policy
+ *
+ * Updates the bucket policy for an S3 bucket. The policy must be a valid JSON
+ * document that defines access permissions.
+ */
+export declare const useSetBucketPolicy: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketPolicyCommandOutput, import("..").EnhancedS3Error, PutBucketPolicyCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketPolicyCommandOutput, import("..").EnhancedS3Error, PutBucketPolicyCommandInput>;
+/**
+ * Hook for deleting S3 bucket policy
+ *
+ * Removes the bucket policy from an S3 bucket, reverting to default access controls.
+ */
+export declare const useDeleteBucketPolicy: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteBucketPolicyCommandOutput, import("..").EnhancedS3Error, DeleteBucketPolicyCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteBucketPolicyCommandOutput, import("..").EnhancedS3Error, DeleteBucketPolicyCommandInput>;
+/**
+ * Hook for retrieving S3 bucket versioning configuration
+ *
+ * Fetches the versioning state of an S3 bucket. Returns information about
+ * whether versioning is enabled, suspended, or never configured.
+ */
+export declare const useGetBucketVersioning: (params?: GetBucketVersioningCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketVersioningCommandOutput, import("..").EnhancedS3Error, GetBucketVersioningCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketVersioningCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket versioning configuration
+ *
+ * Enables or suspends versioning on an S3 bucket. Once versioning is enabled,
+ * it cannot be disabled, only suspended.
+ */
+export declare const useSetBucketVersioning: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketVersioningCommandOutput, import("..").EnhancedS3Error, PutBucketVersioningCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketVersioningCommandOutput, import("..").EnhancedS3Error, PutBucketVersioningCommandInput>;
+/**
+ * Hook for retrieving S3 bucket CORS configuration
+ *
+ * Fetches the Cross-Origin Resource Sharing (CORS) configuration for an S3 bucket.
+ * CORS rules define how web applications from different domains can access bucket resources.
+ */
+export declare const useGetBucketCors: (params?: GetBucketCorsCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketCorsCommandOutput, import("..").EnhancedS3Error, GetBucketCorsCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketCorsCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket CORS configuration
+ *
+ * Sets the CORS configuration for an S3 bucket. CORS rules specify which domains
+ * can access bucket resources and what HTTP methods are allowed.
+ */
+export declare const useSetBucketCors: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketCorsCommandOutput, import("..").EnhancedS3Error, PutBucketCorsCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketCorsCommandOutput, import("..").EnhancedS3Error, PutBucketCorsCommandInput>;
+/**
+ * Hook for deleting S3 bucket CORS configuration
+ *
+ * Removes the CORS configuration from an S3 bucket, disabling cross-origin access.
+ */
+export declare const useDeleteBucketCors: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteBucketCorsCommandOutput, import("..").EnhancedS3Error, DeleteBucketCorsCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteBucketCorsCommandOutput, import("..").EnhancedS3Error, DeleteBucketCorsCommandInput>;
+/**
+ * Hook for retrieving S3 bucket lifecycle configuration
+ *
+ * Fetches the lifecycle configuration for an S3 bucket. Lifecycle rules define
+ * automatic actions like transitioning objects to different storage classes or deleting them.
+ */
+export declare const useGetBucketLifecycle: (params?: GetBucketLifecycleConfigurationCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketLifecycleConfigurationCommandOutput, import("..").EnhancedS3Error, GetBucketLifecycleConfigurationCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketLifecycleConfigurationCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket lifecycle configuration
+ *
+ * Sets the lifecycle configuration for an S3 bucket. Lifecycle rules can automatically
+ * transition objects between storage classes and delete expired objects.
+ */
+export declare const useSetBucketLifecycle: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketLifecycleConfigurationCommandOutput, import("..").EnhancedS3Error, PutBucketLifecycleConfigurationCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketLifecycleConfigurationCommandOutput, import("..").EnhancedS3Error, PutBucketLifecycleConfigurationCommandInput>;
+/**
+ * Hook for deleting S3 bucket lifecycle configuration
+ *
+ * Removes the lifecycle configuration from an S3 bucket, disabling automatic
+ * object transitions and expiration.
+ */
+export declare const useDeleteBucketLifecycle: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteBucketLifecycleCommandOutput, import("..").EnhancedS3Error, DeleteBucketLifecycleCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteBucketLifecycleCommandOutput, import("..").EnhancedS3Error, DeleteBucketLifecycleCommandInput>;
+/**
+ * Hook for retrieving S3 bucket notification configuration
+ *
+ * Fetches the notification configuration for an S3 bucket. Notifications can be
+ * sent to SNS topics, SQS queues, or Lambda functions when certain events occur.
+ */
+export declare const useGetBucketNotification: (params?: GetBucketNotificationConfigurationCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketNotificationConfigurationCommandOutput, import("..").EnhancedS3Error, GetBucketNotificationConfigurationCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketNotificationConfigurationCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket notification configuration
+ *
+ * Sets the notification configuration for an S3 bucket. Configures which events
+ * trigger notifications and where those notifications are sent.
+ */
+export declare const useSetBucketNotification: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketNotificationConfigurationCommandOutput, import("..").EnhancedS3Error, PutBucketNotificationConfigurationCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketNotificationConfigurationCommandOutput, import("..").EnhancedS3Error, PutBucketNotificationConfigurationCommandInput>;
+/**
+ * Hook for retrieving S3 bucket encryption configuration
+ *
+ * Fetches the default encryption configuration for an S3 bucket. This determines
+ * how objects are encrypted when uploaded without explicit encryption settings.
+ */
+export declare const useGetBucketEncryption: (params?: GetBucketEncryptionCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketEncryptionCommandOutput, import("..").EnhancedS3Error, GetBucketEncryptionCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketEncryptionCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket encryption configuration
+ *
+ * Sets the default encryption configuration for an S3 bucket. Objects uploaded
+ * without explicit encryption will use this configuration.
+ */
+export declare const useSetBucketEncryption: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketEncryptionCommandOutput, import("..").EnhancedS3Error, PutBucketEncryptionCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketEncryptionCommandOutput, import("..").EnhancedS3Error, PutBucketEncryptionCommandInput>;
+/**
+ * Hook for retrieving S3 bucket tags
+ *
+ * Fetches the tag set associated with an S3 bucket. Tags are key-value pairs
+ * that provide metadata for organizing and managing buckets.
+ */
+export declare const useGetBucketTagging: (params?: GetBucketTaggingCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketTaggingCommandOutput, import("..").EnhancedS3Error, GetBucketTaggingCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketTaggingCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket tags
+ *
+ * Sets or updates the tag set for an S3 bucket. Tags help organize and categorize
+ * buckets for billing, access control, and management purposes.
+ */
+export declare const useSetBucketTagging: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketTaggingCommandOutput, import("..").EnhancedS3Error, PutBucketTaggingCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketTaggingCommandOutput, import("..").EnhancedS3Error, PutBucketTaggingCommandInput>;
+/**
+ * Hook for deleting S3 bucket tags
+ *
+ * Removes all tags from an S3 bucket. This operation cannot be undone,
+ * so use with caution.
+ */
+export declare const useDeleteBucketTagging: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteBucketTaggingCommandOutput, import("..").EnhancedS3Error, DeleteBucketTaggingCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteBucketTaggingCommandOutput, import("..").EnhancedS3Error, DeleteBucketTaggingCommandInput>;
+export declare const useGetBucketObjectLockConfiguration: (params?: GetObjectLockConfigurationCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectLockConfigurationCommandOutput, import("..").EnhancedS3Error, GetObjectLockConfigurationCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectLockConfigurationCommandOutput, import("..").EnhancedS3Error>;
+export declare const useSetBucketObjectLockConfiguration: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectLockConfigurationCommandOutput, import("..").EnhancedS3Error, PutObjectLockConfigurationCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectLockConfigurationCommandOutput, import("..").EnhancedS3Error, PutObjectLockConfigurationCommandInput>;
+/**
+ * Hook for retrieving S3 bucket replication configuration
+ *
+ * Fetches the replication configuration for an S3 bucket. Replication enables
+ * automatic, asynchronous copying of objects across buckets in different or same regions.
+ */
+export declare const useGetBucketReplication: (params?: GetBucketReplicationCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketReplicationCommandOutput, import("..").EnhancedS3Error, GetBucketReplicationCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketReplicationCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 bucket replication configuration
+ *
+ * Sets the replication configuration for an S3 bucket. Requires versioning to be
+ * enabled on both source and destination buckets.
+ */
+export declare const useSetBucketReplication: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutBucketReplicationCommandOutput, import("..").EnhancedS3Error, PutBucketReplicationCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutBucketReplicationCommandOutput, import("..").EnhancedS3Error, PutBucketReplicationCommandInput>;
+/**
+ * Hook for deleting S3 bucket replication configuration
+ *
+ * Removes the replication configuration from an S3 bucket. Objects that have already
+ * 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>;

package/dist/hooks/bucketConfiguration.js

@@ -0,0 +1,67 @@
+import { DeleteBucketCorsCommand, DeleteBucketLifecycleCommand, DeleteBucketPolicyCommand, DeleteBucketReplicationCommand, DeleteBucketTaggingCommand, GetBucketAclCommand, GetBucketCorsCommand, GetBucketEncryptionCommand, GetBucketLifecycleConfigurationCommand, GetBucketNotificationConfigurationCommand, GetBucketPolicyCommand, GetBucketReplicationCommand, GetBucketTaggingCommand, GetBucketVersioningCommand, GetObjectLockConfigurationCommand, PutBucketAclCommand, PutBucketCorsCommand, PutBucketEncryptionCommand, PutBucketLifecycleConfigurationCommand, PutBucketNotificationConfigurationCommand, PutBucketPolicyCommand, PutBucketReplicationCommand, PutBucketTaggingCommand, PutBucketVersioningCommand, PutObjectLockConfigurationCommand } from "@aws-sdk/client-s3";
+import { useCreateS3QueryHook } from "./factories/useCreateS3QueryHook.js";
+import { useCreateS3MutationHook } from "./factories/useCreateS3MutationHook.js";
+const useGetBucketAcl = useCreateS3QueryHook(GetBucketAclCommand, "GetBucketAcl");
+const useSetBucketAcl = useCreateS3MutationHook(PutBucketAclCommand, "PutBucketAcl", [
+    "GetBucketAcl",
+    "ListBuckets"
+]);
+const useGetBucketPolicy = useCreateS3QueryHook(GetBucketPolicyCommand, "GetBucketPolicy");
+const useSetBucketPolicy = useCreateS3MutationHook(PutBucketPolicyCommand, "PutBucketPolicy", [
+    "GetBucketPolicy",
+    "ListBuckets"
+]);
+const useDeleteBucketPolicy = useCreateS3MutationHook(DeleteBucketPolicyCommand, "DeleteBucketPolicy", [
+    "GetBucketPolicy"
+]);
+const useGetBucketVersioning = useCreateS3QueryHook(GetBucketVersioningCommand, "GetBucketVersioning");
+const useSetBucketVersioning = useCreateS3MutationHook(PutBucketVersioningCommand, "PutBucketVersioning", [
+    "GetBucketVersioning"
+]);
+const useGetBucketCors = useCreateS3QueryHook(GetBucketCorsCommand, "GetBucketCors");
+const useSetBucketCors = useCreateS3MutationHook(PutBucketCorsCommand, "PutBucketCors", [
+    "GetBucketCors",
+    "ListBuckets"
+]);
+const useDeleteBucketCors = useCreateS3MutationHook(DeleteBucketCorsCommand, "DeleteBucketCors", [
+    "GetBucketCors"
+]);
+const useGetBucketLifecycle = useCreateS3QueryHook(GetBucketLifecycleConfigurationCommand, "GetBucketLifecycleConfiguration");
+const useSetBucketLifecycle = useCreateS3MutationHook(PutBucketLifecycleConfigurationCommand, "PutBucketLifecycleConfiguration", [
+    "GetBucketLifecycleConfiguration",
+    "ListBuckets"
+]);
+const useDeleteBucketLifecycle = useCreateS3MutationHook(DeleteBucketLifecycleCommand, "DeleteBucketLifecycle", [
+    "GetBucketLifecycleConfiguration"
+]);
+const useGetBucketNotification = useCreateS3QueryHook(GetBucketNotificationConfigurationCommand, "GetBucketNotificationConfiguration");
+const useSetBucketNotification = useCreateS3MutationHook(PutBucketNotificationConfigurationCommand, "PutBucketNotificationConfiguration", [
+    "GetBucketNotificationConfiguration",
+    "ListBuckets"
+]);
+const useGetBucketEncryption = useCreateS3QueryHook(GetBucketEncryptionCommand, "GetBucketEncryption");
+const useSetBucketEncryption = useCreateS3MutationHook(PutBucketEncryptionCommand, "PutBucketEncryption", [
+    "GetBucketEncryption",
+    "ListBuckets"
+]);
+const useGetBucketTagging = useCreateS3QueryHook(GetBucketTaggingCommand, "GetBucketTagging");
+const useSetBucketTagging = useCreateS3MutationHook(PutBucketTaggingCommand, "PutBucketTagging", [
+    "GetBucketTagging",
+    "ListBuckets"
+]);
+const useDeleteBucketTagging = useCreateS3MutationHook(DeleteBucketTaggingCommand, "DeleteBucketTagging", [
+    "GetBucketTagging"
+]);
+const useGetBucketObjectLockConfiguration = useCreateS3QueryHook(GetObjectLockConfigurationCommand, "GetObjectLockConfiguration");
+const useSetBucketObjectLockConfiguration = useCreateS3MutationHook(PutObjectLockConfigurationCommand, "PutObjectLockConfiguration", [
+    "GetObjectLockConfiguration"
+]);
+const useGetBucketReplication = useCreateS3QueryHook(GetBucketReplicationCommand, "GetBucketReplication");
+const useSetBucketReplication = useCreateS3MutationHook(PutBucketReplicationCommand, "PutBucketReplication", [
+    "GetBucketReplication",
+    "ListBuckets"
+]);
+const useDeleteBucketReplication = useCreateS3MutationHook(DeleteBucketReplicationCommand, "DeleteBucketReplication", [
+    "GetBucketReplication"
+]);
+export { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning };

package/dist/hooks/bucketOperations.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Basic S3 Bucket Operations
+ *
+ * This file contains hooks for fundamental bucket operations like
+ * listing, creating, and deleting buckets.
+ */
+import { ListBucketsCommandInput, ListBucketsCommandOutput, CreateBucketCommandInput, CreateBucketCommandOutput, DeleteBucketCommandInput, DeleteBucketCommandOutput, GetBucketLocationCommandInput, GetBucketLocationCommandOutput } from "@aws-sdk/client-s3";
+/**
+ * Hook for listing all S3 buckets
+ *
+ * Lists all S3 buckets accessible to the authenticated user.
+ * Note: Unlike objects listing, bucket listing doesn't support pagination
+ * as S3 returns all buckets in a single response.
+ */
+export declare const useBuckets: (params?: ListBucketsCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<ListBucketsCommandOutput, import("..").EnhancedS3Error, ListBucketsCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<ListBucketsCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for retrieving S3 bucket location constraint information
+ *
+ * Fetches the AWS region where an S3 bucket is located. This is essential
+ * for cross-region operations and understanding bucket placement.
+ */
+export declare const useGetBucketLocation: (params?: GetBucketLocationCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetBucketLocationCommandOutput, import("..").EnhancedS3Error, GetBucketLocationCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetBucketLocationCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for creating a new S3 bucket
+ *
+ * Creates a new S3 bucket with specified configuration options.
+ * Automatically invalidates the buckets list after successful creation.
+ */
+export declare const useCreateBucket: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<CreateBucketCommandOutput, import("..").EnhancedS3Error, CreateBucketCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<CreateBucketCommandOutput, import("..").EnhancedS3Error, CreateBucketCommandInput>;
+/**
+ * Hook for deleting an S3 bucket
+ *
+ * Deletes an empty S3 bucket. The bucket must be empty before deletion.
+ * Automatically invalidates the buckets list after successful deletion.
+ */
+export declare const useDeleteBucket: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteBucketCommandOutput, import("..").EnhancedS3Error, DeleteBucketCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteBucketCommandOutput, import("..").EnhancedS3Error, DeleteBucketCommandInput>;

package/dist/hooks/bucketOperations.js

@@ -0,0 +1,12 @@
+import { CreateBucketCommand, DeleteBucketCommand, GetBucketLocationCommand, ListBucketsCommand } from "@aws-sdk/client-s3";
+import { useCreateS3QueryHook } from "./factories/useCreateS3QueryHook.js";
+import { useCreateS3MutationHook } from "./factories/useCreateS3MutationHook.js";
+const useBuckets = useCreateS3QueryHook(ListBucketsCommand, "ListBuckets");
+const useGetBucketLocation = useCreateS3QueryHook(GetBucketLocationCommand, "GetBucketLocation");
+const useCreateBucket = useCreateS3MutationHook(CreateBucketCommand, "CreateBucket", [
+    "ListBuckets"
+]);
+const useDeleteBucket = useCreateS3MutationHook(DeleteBucketCommand, "DeleteBucket", [
+    "ListBuckets"
+]);
+export { useBuckets, useCreateBucket, useDeleteBucket, useGetBucketLocation };

package/dist/hooks/factories/__tests__/useCreateS3FunctionMutationHook.test.d.ts

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