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

package/dist/components/ui/Table.elements.js

@@ -0,0 +1,87 @@
+import { jsx } from "react/jsx-runtime";
+import { Text, spacing } from "@scality/core-ui";
+import { Box } from "@scality/core-ui/dist/next";
+import styled_components from "styled-components";
+const Table = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        height: "100%",
+        overflow: "auto",
+        width: "100%",
+        ...props,
+        children: children
+    });
+const Body = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        display: "flex",
+        flexDirection: "column",
+        ...props,
+        children: children
+    });
+const Group = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        marginBottom: spacing.r28,
+        ...props,
+        children: children
+    });
+const GroupName = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        marginBottom: spacing.r10,
+        ...props,
+        children: /*#__PURE__*/ jsx(Text, {
+            isEmphazed: true,
+            color: "textPrimary",
+            children: children
+        })
+    });
+const GroupContent = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        display: "flex",
+        flexDirection: "column",
+        ...props,
+        children: children
+    });
+const Row = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        position: "relative",
+        display: "flex",
+        flexDirection: "row",
+        alignItems: "center",
+        marginBottom: spacing.r8,
+        minHeight: spacing.r28,
+        ...props,
+        children: children
+    });
+const RawKey = styled_components.div`
+  color: ${(props)=>props.principal ? props.theme.textPrimary : props.theme?.textSecondary};
+  font-weight: ${(props)=>props.principal ? "bold" : "normal"};
+  ${(props)=>props.required ? `
+        &:after {
+            content: '*';
+        }
+    ` : ""}
+`;
+const Key = styled_components(RawKey)`
+  && {
+    flex: ${(props)=>props.size || "0.35"};
+    min-width: 0;
+  }
+`;
+const Value = styled_components.div`
+  flex: 0.65;
+  flex-direction: column;
+  min-width: 0;
+  color: ${(props)=>props.theme?.textPrimary};
+  width: ${(props)=>props.width};
+`;
+const TableContainer = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+        display: "flex",
+        flexDirection: "column",
+        height: "100%",
+        ...props,
+        children: children
+    });
+const GroupValues = styled_components.div`
+  display: flex;
+  flex: ${(props)=>props.size || "0.65"};
+  justify-content: space-between;
+  align-items: center;
+  min-width: 0;
+`;
+const ExtraCell = styled_components.div`
+  margin-left: ${(props)=>props.marginLeft || "1.429rem"};
+`;
+export { Body, ExtraCell, Group, GroupContent, GroupName, GroupValues, Key, Row, Table, TableContainer, Value };

package/dist/config/factory.d.ts

@@ -0,0 +1,52 @@
+import type { S3ClientConfiguration } from "./types";
+import type { S3BrowserConfig, S3Credentials } from "../types";
+/**
+ * Configuration factory that uses build-time constants
+ * No runtime environment detection or hardcoded values
+ */
+export declare class S3ConfigurationFactory {
+    /**
+     * Load runtime configuration from config.json
+     * Should be called at app startup
+     */
+    static loadRuntimeConfig(): Promise<void>;
+    private static getBuildTimeConfig;
+    /**
+     * Create S3 client configuration based on build-time settings
+     */
+    static createClientConfiguration(credentials: S3Credentials): S3BrowserConfig & {
+        credentials: S3Credentials;
+    };
+    /**
+     * Create proxy middleware configuration
+     */
+    static createProxyConfiguration(): S3ClientConfiguration;
+    /**
+     * Check if proxy middleware should be enabled
+     */
+    static shouldUseProxyMiddleware(): boolean;
+    /**
+     * Get build-time environment info for debugging
+     */
+    static getBuildInfo(): {
+        environment: string;
+        useProxy: boolean;
+        s3Endpoint: string;
+        proxyEndpoint: string | undefined;
+    };
+}
+/**
+ * Convenience functions for common use cases
+ */
+export declare const createS3Config: (credentials: S3Credentials) => S3BrowserConfig & {
+    credentials: S3Credentials;
+};
+export declare const shouldUseProxy: () => boolean;
+export declare const getProxyConfig: () => S3ClientConfiguration;
+export declare const getBuildInfo: () => {
+    environment: string;
+    useProxy: boolean;
+    s3Endpoint: string;
+    proxyEndpoint: string | undefined;
+};
+export declare const loadRuntimeConfig: () => Promise<void>;

package/dist/config/factory.js

@@ -0,0 +1,70 @@
+let runtimeConfig = null;
+class S3ConfigurationFactory {
+    static async loadRuntimeConfig() {
+        try {
+            const response = await fetch("/_/s3-browser/config.json");
+            if (response.ok) {
+                const data = await response.json();
+                runtimeConfig = data.s3;
+                console.log("Loaded runtime S3 configuration:", runtimeConfig);
+            }
+        } catch (error) {
+            console.warn("Could not load runtime config, using build-time config:", error);
+        }
+    }
+    static getBuildTimeConfig() {
+        return {
+            s3: __S3_CONFIG__,
+            dev: __DEV_CONFIG__,
+            isDevelopment: __IS_DEVELOPMENT__,
+            isProduction: __IS_PRODUCTION__
+        };
+    }
+    static createClientConfiguration(credentials) {
+        const buildConfig = this.getBuildTimeConfig();
+        const s3Config = buildConfig.isProduction && runtimeConfig ? runtimeConfig : buildConfig.s3;
+        const baseConfig = {
+            credentials,
+            region: s3Config.region,
+            forcePathStyle: s3Config.forcePathStyle ?? true,
+            endpoint: s3Config.endpoint
+        };
+        if (buildConfig.isDevelopment && buildConfig.dev.useProxy && buildConfig.dev.proxyEndpoint) baseConfig.endpoint = buildConfig.dev.proxyEndpoint;
+        return baseConfig;
+    }
+    static createProxyConfiguration() {
+        const buildConfig = this.getBuildTimeConfig();
+        const config = {
+            endpoint: buildConfig.s3.endpoint,
+            region: buildConfig.s3.region,
+            forcePathStyle: buildConfig.s3.forcePathStyle,
+            useProxy: buildConfig.isDevelopment && buildConfig.dev.useProxy
+        };
+        if (config.useProxy) config.proxyConfig = {
+            realHost: buildConfig.s3.realHost,
+            proxyBasePath: buildConfig.dev.proxyBasePath,
+            proxyHost: buildConfig.dev.proxyHost,
+            proxyPort: buildConfig.dev.proxyPort
+        };
+        return config;
+    }
+    static shouldUseProxyMiddleware() {
+        const buildConfig = this.getBuildTimeConfig();
+        return buildConfig.isDevelopment && buildConfig.dev.useProxy;
+    }
+    static getBuildInfo() {
+        const buildConfig = this.getBuildTimeConfig();
+        return {
+            environment: buildConfig.isDevelopment ? "development" : "production",
+            useProxy: buildConfig.dev.useProxy,
+            s3Endpoint: buildConfig.s3.endpoint,
+            proxyEndpoint: buildConfig.dev.proxyEndpoint
+        };
+    }
+}
+const createS3Config = (credentials)=>S3ConfigurationFactory.createClientConfiguration(credentials);
+const shouldUseProxy = ()=>S3ConfigurationFactory.shouldUseProxyMiddleware();
+const getProxyConfig = ()=>S3ConfigurationFactory.createProxyConfiguration();
+const getBuildInfo = ()=>S3ConfigurationFactory.getBuildInfo();
+const loadRuntimeConfig = ()=>S3ConfigurationFactory.loadRuntimeConfig();
+export { S3ConfigurationFactory, createS3Config, getBuildInfo, getProxyConfig, loadRuntimeConfig, shouldUseProxy };

package/dist/config/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Build-time configuration types injected by RSBuild
+ */
+export interface S3Configuration {
+    endpoint: string;
+    region: string;
+    realHost: string;
+    forcePathStyle: boolean;
+}
+export interface DevelopmentConfiguration {
+    useProxy: boolean;
+    proxyEndpoint?: string;
+    proxyBasePath: string;
+    proxyHost: string;
+    proxyPort: number;
+}
+export interface BuildTimeConfig {
+    s3: S3Configuration;
+    dev: DevelopmentConfiguration;
+    isDevelopment: boolean;
+    isProduction: boolean;
+}
+/**
+ * Runtime configuration for S3 client
+ */
+export interface S3ClientConfiguration {
+    endpoint: string;
+    region: string;
+    forcePathStyle: boolean;
+    useProxy: boolean;
+    proxyConfig?: {
+        realHost: string;
+        proxyBasePath: string;
+        proxyHost: string;
+        proxyPort: number;
+    };
+}
+/**
+ * Global type declarations for build-time constants
+ */
+declare global {
+    const __S3_CONFIG__: S3Configuration;
+    const __DEV_CONFIG__: DevelopmentConfiguration;
+    const __IS_DEVELOPMENT__: boolean;
+    const __IS_PRODUCTION__: boolean;
+}

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: [
+                    {
+                        objects: [],
+                        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: [
+                    {
+                        objects: [
+                            {
+                                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: [
+                    {
+                        objects: [],
+                        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: [
+                    {
+                        objects: [
+                            {
+                                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,147 @@
+/**
+ * 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 } 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>;

package/dist/hooks/bucketConfiguration.js

@@ -0,0 +1,59 @@
+import { DeleteBucketCorsCommand, DeleteBucketLifecycleCommand, DeleteBucketPolicyCommand, DeleteBucketTaggingCommand, GetBucketAclCommand, GetBucketCorsCommand, GetBucketEncryptionCommand, GetBucketLifecycleConfigurationCommand, GetBucketNotificationConfigurationCommand, GetBucketPolicyCommand, GetBucketTaggingCommand, GetBucketVersioningCommand, GetObjectLockConfigurationCommand, PutBucketAclCommand, PutBucketCorsCommand, PutBucketEncryptionCommand, PutBucketLifecycleConfigurationCommand, PutBucketNotificationConfigurationCommand, PutBucketPolicyCommand, 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"
+]);
+export { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketTagging, useGetBucketVersioning, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, 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 {};