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

package/dist/hooks/useBucketConfigEditor.js

@@ -0,0 +1,82 @@
+import { useCallback, useEffect, useMemo } from "react";
+import { useForm } from "react-hook-form";
+import { useDataBrowserNavigate } from "./useDataBrowserNavigate.js";
+const useBucketConfigEditor = (config)=>{
+    const navigate = useDataBrowserNavigate();
+    const { bucketName } = config;
+    const form = useForm({
+        mode: 'onChange',
+        defaultValues: {
+            content: ''
+        }
+    });
+    const { watch, reset } = form;
+    const content = watch('content');
+    const isCreateMode = useMemo(()=>{
+        if (!config.errorInstance) return false;
+        return config.notFoundErrorNames.some((name)=>config.errorInstance?.name === name);
+    }, [
+        config.errorInstance,
+        config.notFoundErrorNames
+    ]);
+    const initialValue = useMemo(()=>{
+        if (config.initialContent) try {
+            const parsed = JSON.parse(config.initialContent);
+            return JSON.stringify(parsed, null, 2);
+        } catch  {
+            return config.initialContent;
+        }
+        return config.defaultTemplate;
+    }, [
+        config.initialContent,
+        config.defaultTemplate
+    ]);
+    useEffect(()=>{
+        reset({
+            content: initialValue
+        });
+    }, [
+        initialValue,
+        reset
+    ]);
+    const isValidFormat = useMemo(()=>config.validate(content).isValid, [
+        content,
+        config.validate
+    ]);
+    const handleBeforeMount = useCallback((monaco)=>{
+        const jsonLanguage = monaco.languages.json;
+        if (jsonLanguage?.jsonDefaults) if (config.monacoSchema) jsonLanguage.jsonDefaults.setDiagnosticsOptions({
+            validate: true,
+            schemas: [
+                {
+                    uri: 'http://myserver/schema.json',
+                    fileMatch: [
+                        '*'
+                    ],
+                    schema: config.monacoSchema
+                }
+            ]
+        });
+        else jsonLanguage.jsonDefaults.setDiagnosticsOptions({
+            validate: true
+        });
+    }, [
+        config.monacoSchema
+    ]);
+    const navigateToBucket = useCallback(()=>{
+        navigate(`/buckets/${bucketName}`);
+    }, [
+        navigate,
+        bucketName
+    ]);
+    return {
+        bucketName,
+        form,
+        content,
+        isCreateMode,
+        isValidFormat,
+        handleBeforeMount,
+        navigateToBucket
+    };
+};
+export { useBucketConfigEditor };

package/dist/hooks/useDataBrowserNavigate.d.ts

@@ -0,0 +1,28 @@
+import { type NavigateOptions } from 'react-router';
+/**
+ * Normalizes a path by prefixing it with the basePath.
+ * Handles edge cases like missing slashes, relative paths, and root paths.
+ *
+ * @param basePath - The base path prefix (e.g., "/accounts/my-account/buckets")
+ * @param to - The target path (e.g., "/my-bucket")
+ * @returns The normalized absolute path (e.g., "/accounts/my-account/buckets/my-bucket")
+ */
+export declare const normalizePath: (basePath: string, to: string) => string;
+/**
+ * Hook for navigation with automatic basePath prefixing.
+ * Must be used within DataBrowserUI component.
+ *
+ * This hook wraps react-router's useNavigate and automatically prefixes all
+ * navigation paths with the basePath configured in DataBrowserUI props.
+ * This allows internal navigation to work correctly when DataBrowserUI is
+ * mounted at any route within the application.
+ *
+ * @example
+ * ```tsx
+ * // If DataBrowserUI has basePath="/accounts/my-account/buckets"
+ * const navigate = useDataBrowserNavigate();
+ * navigate('/my-bucket'); // Navigates to "/accounts/my-account/buckets/my-bucket"
+ * navigate(-1); // History navigation works as normal (no prefixing)
+ * ```
+ */
+export declare const useDataBrowserNavigate: () => (to: string | number, options?: NavigateOptions) => void;

package/dist/hooks/useDataBrowserNavigate.js

@@ -0,0 +1,24 @@
+import { useCallback } from "react";
+import { useNavigate } from "react-router";
+import { useDataBrowserUICustomization } from "../contexts/DataBrowserUICustomizationContext.js";
+const normalizePath = (basePath, to)=>{
+    if (!basePath) return to;
+    if (!to.startsWith('/')) return to;
+    const base = basePath.replace(/^\/+|\/+$/g, '');
+    const path = to.replace(/^\/+/, '');
+    if (!path) return base ? `/${base}` : '/';
+    return `/${base}/${path}`.replace(/\/+/g, '/');
+};
+const useDataBrowserNavigate = ()=>{
+    const navigate = useNavigate();
+    const { basePath = '' } = useDataBrowserUICustomization();
+    return useCallback((to, options)=>{
+        if ('number' == typeof to) return void navigate(to);
+        const targetPath = normalizePath(basePath, to);
+        options ? navigate(targetPath, options) : navigate(targetPath);
+    }, [
+        navigate,
+        basePath
+    ]);
+};
+export { normalizePath, useDataBrowserNavigate };

package/dist/hooks/useDeleteBucketConfigRule.d.ts

@@ -0,0 +1,26 @@
+import type { UseMutationResult } from '@tanstack/react-query';
+interface BucketCommandInput {
+    Bucket: string | undefined;
+}
+interface UseDeleteBucketConfigRuleOptions<TRule extends {
+    ID?: string;
+}, TUpdateInput extends BucketCommandInput, TUpdateOutput, TDeleteInput extends BucketCommandInput, TDeleteOutput, TError = unknown> {
+    bucketName: string;
+    ruleId: string;
+    rules: TRule[];
+    updateMutation: UseMutationResult<TUpdateOutput, TError, TUpdateInput, unknown>;
+    deleteMutation: UseMutationResult<TDeleteOutput, TError, TDeleteInput, unknown>;
+    buildUpdateInput: (remainingRules: TRule[]) => Omit<TUpdateInput, 'Bucket'>;
+    successMessage?: string;
+    errorMessage?: string;
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+}
+interface UseDeleteBucketConfigRuleReturn {
+    isDeleting: boolean;
+    deleteRule: () => void;
+}
+export declare function useDeleteBucketConfigRule<TRule extends {
+    ID?: string;
+}, TUpdateInput extends BucketCommandInput = BucketCommandInput, TUpdateOutput = unknown, TDeleteInput extends BucketCommandInput = BucketCommandInput, TDeleteOutput = unknown, TError = unknown>({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage, errorMessage, onSuccess, onError, }: UseDeleteBucketConfigRuleOptions<TRule, TUpdateInput, TUpdateOutput, TDeleteInput, TDeleteOutput, TError>): UseDeleteBucketConfigRuleReturn;
+export {};

package/dist/hooks/useDeleteBucketConfigRule.js

@@ -0,0 +1,46 @@
+import { useToast } from "@scality/core-ui";
+function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage = 'Rule deleted successfully', errorMessage = 'Failed to delete rule', onSuccess, onError }) {
+    const { showToast } = useToast();
+    const { mutate: updateConfig, status: updateStatus } = updateMutation;
+    const { mutate: deleteConfig, status: deleteStatus } = deleteMutation;
+    const isDeleting = 'pending' === updateStatus || 'pending' === deleteStatus;
+    const deleteRule = ()=>{
+        const remainingRules = rules.filter((rule)=>rule.ID !== ruleId);
+        const handleSuccess = ()=>{
+            showToast({
+                open: true,
+                message: successMessage,
+                status: 'success'
+            });
+            onSuccess?.();
+        };
+        const handleError = (error)=>{
+            const displayMessage = error instanceof Error && error.message ? error.message : errorMessage;
+            const errorToReport = error instanceof Error ? error : new Error(displayMessage);
+            showToast({
+                open: true,
+                message: displayMessage,
+                status: 'error'
+            });
+            onError?.(errorToReport);
+        };
+        if (0 === remainingRules.length) deleteConfig({
+            Bucket: bucketName
+        }, {
+            onSuccess: handleSuccess,
+            onError: handleError
+        });
+        else updateConfig({
+            Bucket: bucketName,
+            ...buildUpdateInput(remainingRules)
+        }, {
+            onSuccess: handleSuccess,
+            onError: handleError
+        });
+    };
+    return {
+        isDeleting,
+        deleteRule
+    };
+}
+export { useDeleteBucketConfigRule };

package/dist/hooks/useEmptyBucket.d.ts

@@ -0,0 +1,27 @@
+export interface EmptyBucketResult {
+    success: boolean;
+    deletedCount: number;
+    errors: Array<{
+        key: string;
+        code?: string;
+        message?: string;
+    }>;
+    limitReached: boolean;
+}
+interface UseEmptyBucketOptions {
+    maxObjects?: number;
+    maxKeysPerList?: number;
+    bypassGovernanceRetention?: boolean;
+    onProgress?: (deletedCount: number, totalAttempted: number) => void;
+    onSuccess?: (result: EmptyBucketResult) => void;
+    onError?: (error: Error) => void;
+}
+interface UseEmptyBucketReturn {
+    emptyBucket: (bucketName: string) => Promise<EmptyBucketResult | null>;
+    isEmptying: boolean;
+    error: Error | null;
+    result: EmptyBucketResult | null;
+    reset: () => void;
+}
+export declare const useEmptyBucket: (options?: UseEmptyBucketOptions) => UseEmptyBucketReturn;
+export {};

package/dist/hooks/useEmptyBucket.js

@@ -0,0 +1,116 @@
+import { DeleteObjectsCommand, ListObjectVersionsCommand } from "@aws-sdk/client-s3";
+import { useCallback, useState } from "react";
+import { useInvalidateQueries } from "../components/providers/DataBrowserProvider.js";
+import { useS3Client } from "./useS3Client.js";
+const useEmptyBucket = (options = {})=>{
+    const { maxObjects = 20000, maxKeysPerList = 1000, bypassGovernanceRetention = true, onProgress, onSuccess, onError } = options;
+    const [isEmptying, setIsEmptying] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const s3Client = useS3Client();
+    const invalidateQueries = useInvalidateQueries();
+    const emptyBucket = useCallback(async (bucketName)=>{
+        setIsEmptying(true);
+        setError(null);
+        setResult(null);
+        try {
+            let deletedCount = 0;
+            let totalAttempted = 0;
+            let keyMarker;
+            let versionIdMarker;
+            const allErrors = [];
+            let limitReached = false;
+            while(totalAttempted < maxObjects){
+                const listCommand = new ListObjectVersionsCommand({
+                    Bucket: bucketName,
+                    MaxKeys: maxKeysPerList,
+                    KeyMarker: keyMarker,
+                    VersionIdMarker: versionIdMarker
+                });
+                const listResponse = await s3Client.send(listCommand);
+                const objectsToDelete = [];
+                if (listResponse.Versions) objectsToDelete.push(...listResponse.Versions.filter((v)=>v.Key).map((v)=>({
+                        Key: v.Key,
+                        VersionId: v.VersionId
+                    })));
+                if (listResponse.DeleteMarkers) objectsToDelete.push(...listResponse.DeleteMarkers.filter((dm)=>dm.Key).map((dm)=>({
+                        Key: dm.Key,
+                        VersionId: dm.VersionId
+                    })));
+                if (0 === objectsToDelete.length) break;
+                const deleteCommand = new DeleteObjectsCommand({
+                    Bucket: bucketName,
+                    Delete: {
+                        Objects: objectsToDelete
+                    },
+                    BypassGovernanceRetention: bypassGovernanceRetention
+                });
+                const deleteResponse = await s3Client.send(deleteCommand);
+                const successCount = deleteResponse.Deleted?.length || 0;
+                deletedCount += successCount;
+                totalAttempted += objectsToDelete.length;
+                if (deleteResponse.Errors) allErrors.push(...deleteResponse.Errors.map((error)=>({
+                        key: error.Key || 'unknown',
+                        code: error.Code,
+                        message: error.Message
+                    })));
+                onProgress?.(deletedCount, totalAttempted);
+                if (!listResponse.IsTruncated) break;
+                if (totalAttempted >= maxObjects) {
+                    limitReached = true;
+                    break;
+                }
+                keyMarker = listResponse.NextKeyMarker;
+                versionIdMarker = listResponse.NextVersionIdMarker;
+            }
+            const bucketResult = {
+                success: 0 === allErrors.length,
+                deletedCount,
+                errors: allErrors,
+                limitReached
+            };
+            setResult(bucketResult);
+            invalidateQueries({
+                queryKey: [
+                    'ListObjects'
+                ]
+            });
+            invalidateQueries({
+                queryKey: [
+                    'ListObjectVersions'
+                ]
+            });
+            onSuccess?.(bucketResult);
+            return bucketResult;
+        } catch (err) {
+            const errorObj = err instanceof Error ? err : new Error('Failed to empty bucket');
+            setError(errorObj);
+            onError?.(errorObj);
+            return null;
+        } finally{
+            setIsEmptying(false);
+        }
+    }, [
+        s3Client,
+        invalidateQueries,
+        maxObjects,
+        maxKeysPerList,
+        bypassGovernanceRetention,
+        onProgress,
+        onSuccess,
+        onError
+    ]);
+    const reset = useCallback(()=>{
+        setIsEmptying(false);
+        setError(null);
+        setResult(null);
+    }, []);
+    return {
+        emptyBucket,
+        isEmptying,
+        error,
+        result,
+        reset
+    };
+};
+export { useEmptyBucket };

package/dist/hooks/useFeatures.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook to check if a feature is enabled in the S3 configuration.
+ *
+ * @param feature - The feature name to check
+ * @returns true if enabled, false if disabled, undefined if config not available
+ */
+export declare function useFeatures(feature: string): boolean | undefined;

package/dist/hooks/useFeatures.js

@@ -0,0 +1,8 @@
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+function useFeatures(feature) {
+    const { getS3Config } = useDataBrowserContext();
+    if (!getS3Config) return;
+    const config = getS3Config();
+    return config.features?.includes(feature) ?? false;
+}
+export { useFeatures };

package/dist/hooks/useISVBucketDetection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hook to detect if a bucket is managed by any ISV (Veeam or Commvault)
+ * Returns comprehensive information about ISV bucket status
+ *
+ * This hook fetches bucket tags once and derives all ISV-related states from it,
+ * avoiding multiple API calls for the same data.
+ */
+export declare const useISVBucketStatus: (bucketName: string) => {
+    isVeeamBucket: boolean;
+    isCommvaultBucket: boolean;
+    isISVManaged: boolean;
+    isvApplication: string | undefined;
+    isLoading: boolean | undefined;
+    bucketTagsStatus: "error" | "success" | "pending";
+};

package/dist/hooks/useISVBucketDetection.js

@@ -0,0 +1,27 @@
+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";
+const useISVBucketStatus = (bucketName)=>{
+    const isISVFeatureEnabled = useFeatures('ISV');
+    const { data: bucketTags, status: bucketTagsStatus } = useGetBucketTagging({
+        Bucket: bucketName
+    }, {
+        enabled: true === isISVFeatureEnabled
+    });
+    const veeamTagApplication = bucketTags?.TagSet?.find((tag)=>tag.Key === BUCKET_TAG_VEEAM_APPLICATION)?.Value;
+    const ISVApplicationTag = bucketTags?.TagSet?.find((tag)=>tag.Key === BUCKET_TAG_APPLICATION)?.Value;
+    const isVeeamBucket = veeamTagApplication === VEEAM_BACKUP_REPLICATION || veeamTagApplication === VEEAM_OFFICE_365 || veeamTagApplication === VEEAM_OFFICE_365_V8;
+    const isISVBucketTagAsVeeam = ISVApplicationTag === VEEAM_BACKUP_REPLICATION || ISVApplicationTag === VEEAM_VBO_APPLICATION;
+    const isCommvaultBucket = ISVApplicationTag === COMMVAULT_APPLICATION;
+    const isVeeam = isVeeamBucket || isISVBucketTagAsVeeam;
+    const isISVManaged = isVeeam || isCommvaultBucket;
+    return {
+        isVeeamBucket: isVeeam,
+        isCommvaultBucket,
+        isISVManaged,
+        isvApplication: isCommvaultBucket ? 'Commvault' : isVeeam ? 'Veeam' : void 0,
+        isLoading: isISVFeatureEnabled && 'pending' === bucketTagsStatus,
+        bucketTagsStatus
+    };
+};
+export { useISVBucketStatus };

package/dist/hooks/useIsBucketEmpty.js

@@ -1,16 +1,16 @@
 import { useMemo } from "react";
 import { useListObjects } from "./objectOperations.js";
-const isInfiniteData = (data)=>null != data && "object" == typeof data && "pages" in data && Array.isArray(data.pages);
+const isInfiniteData = (data)=>null != data && 'object' == typeof data && 'pages' in data && Array.isArray(data.pages);
 const useIsBucketEmpty = (bucketName)=>{
     const { data, status, error } = useListObjects({
         Bucket: bucketName,
         MaxKeys: 1,
-        Delimiter: "/"
+        Delimiter: '/'
     }, {
         enabled: !!bucketName
     });
     const isEmpty = useMemo(()=>{
-        if ("pending" === status || !data) return null;
+        if ('pending' === status || !data) return null;
         if (!isInfiniteData(data)) return null;
         for (const page of data.pages){
             if (page?.Contents && page.Contents.length > 0) {
@@ -29,7 +29,7 @@ const useIsBucketEmpty = (bucketName)=>{
     ]);
     return {
         isEmpty,
-        isLoading: "pending" === status,
+        isLoading: 'pending' === status,
         error: error instanceof Error ? error : null
     };
 };

package/dist/hooks/useLimitedAccessFlow.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Limited Access Flow Orchestrator
+ *
+ * This module centralizes all logic related to handling users with limited S3 permissions
+ * (specifically users who lack ListBuckets permission but have access to specific buckets).
+ *
+ * It provides a clean abstraction that:
+ * - Encapsulates storage key patterns
+ * - Manages the limited access flag
+ * - Provides navigation logic
+ * - Coordinates between authentication, storage, and routing
+ */
+import type { LoginConfig } from './loginOperations';
+export interface UseLimitedAccessFlowOptions {
+    /**
+     * Callback invoked when a user successfully authenticates with limited access.
+     * This should be used to persist the config and transition the app state.
+     */
+    onLimitedAccessGranted: (config: LoginConfig) => void;
+}
+export interface LimitedAccessFlowHandlers {
+    /**
+     * Activates the limited access flow for a given S3 configuration.
+     * Sets the necessary flags and navigates to the bucket accessor form.
+     */
+    activateLimitedAccessFlow: (config: LoginConfig) => void;
+}
+/**
+ * Hook that orchestrates the limited access flow.
+ *
+ * This hook provides methods to activate and check the limited access mode
+ * for users who lack ListBuckets permission.
+ *
+ * @example
+ * ```tsx
+ * const { activateLimitedAccessFlow } = useLimitedAccessFlow({
+ *   onLimitedAccessGranted: (config) => {
+ *     setAppConfig(config);
+ *   }
+ * });
+ *
+ * // In login error handler:
+ * if (error.name === 'AccessDenied') {
+ *   activateLimitedAccessFlow(variables);
+ * }
+ * ```
+ */
+export declare const useLimitedAccessFlow: (options: UseLimitedAccessFlowOptions) => LimitedAccessFlowHandlers;

package/dist/hooks/useLimitedAccessFlow.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { useNavigate } from "react-router";
+import { computeS3ConfigIdentifier } from "../utils/s3ConfigIdentifier.js";
+import { setLimitedAccessFlag } from "./useAccessibleBuckets.js";
+const useLimitedAccessFlow = (options)=>{
+    const navigate = useNavigate();
+    const { onLimitedAccessGranted } = options;
+    const activateLimitedAccessFlow = useCallback((config)=>{
+        const s3ConfigIdentifier = computeS3ConfigIdentifier(config);
+        setLimitedAccessFlag(s3ConfigIdentifier, true);
+        onLimitedAccessGranted(config);
+        navigate('/buckets/-/access', {
+            replace: true
+        });
+    }, [
+        navigate,
+        onLimitedAccessGranted
+    ]);
+    return {
+        activateLimitedAccessFlow
+    };
+};
+export { useLimitedAccessFlow };

package/dist/hooks/useS3Client.d.ts

@@ -1 +1,7 @@
+/**
+ * Hook to get the S3 client instance.
+ *
+ * Recreates client only when s3ConfigIdentifier changes.
+ * The client is memoized to avoid unnecessary recreations.
+ */
 export declare const useS3Client: () => import("@aws-sdk/client-s3").S3Client;

package/dist/hooks/useS3Client.js

@@ -2,12 +2,13 @@ import { useMemo } from "react";
 import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
 import { createS3Client } from "../utils/s3Client.js";
 const useS3Client = ()=>{
-    const { getS3Config } = useDataBrowserContext();
+    const { s3ConfigIdentifier, getS3Config } = useDataBrowserContext();
+    if (!getS3Config) throw new Error('useS3Client: S3 config not available. Ensure DataBrowserProvider has getS3Config prop set.');
     return useMemo(()=>{
         const config = getS3Config();
         return createS3Client(config);
     }, [
-        getS3Config
+        s3ConfigIdentifier
     ]);
 };
 export { useS3Client };

package/dist/hooks/useS3ConfigSwitch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hook that handles navigation and query cleanup when S3 config changes.
+ * Must be used inside both DataBrowserProvider and DataBrowserUICustomizationProvider.
+ *
+ * When the S3 config identifier changes:
+ * - Navigates to the buckets page first (to trigger component unmounting)
+ * - Clears all queries associated with the previous config (after navigation)
+ *
+ * @internal This hook is designed for internal use within DataBrowserUI only.
+ */
+export declare const useS3ConfigSwitch: () => void;

package/dist/hooks/useS3ConfigSwitch.js

@@ -0,0 +1,37 @@
+import { useQueryClient } from "@tanstack/react-query";
+import { useEffect, useRef } from "react";
+import { useNavigate } from "react-router";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+import { useDataBrowserUICustomization } from "../contexts/DataBrowserUICustomizationContext.js";
+import { normalizePath } from "./useDataBrowserNavigate.js";
+const useS3ConfigSwitch = ()=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
+    const { basePath = '' } = useDataBrowserUICustomization();
+    const queryClient = useQueryClient();
+    const navigate = useNavigate();
+    const prevConfigIdRef = useRef();
+    useEffect(()=>{
+        if (void 0 !== prevConfigIdRef.current && prevConfigIdRef.current !== s3ConfigIdentifier) {
+            const previousConfigId = prevConfigIdRef.current;
+            const bucketsPath = normalizePath(basePath, '/buckets');
+            navigate(bucketsPath, {
+                replace: true
+            });
+            queueMicrotask(()=>{
+                queryClient.removeQueries({
+                    queryKey: [
+                        previousConfigId
+                    ],
+                    exact: false
+                });
+            });
+        }
+        prevConfigIdRef.current = s3ConfigIdentifier;
+    }, [
+        s3ConfigIdentifier,
+        navigate,
+        basePath,
+        queryClient
+    ]);
+};
+export { useS3ConfigSwitch };

package/dist/hooks/useSupportedNotificationEvents.d.ts

@@ -0,0 +1,6 @@
+import type { S3EventType } from '../config/types';
+/**
+ * Hook to get supported notification events from the DataBrowser configuration
+ * If no supported events are configured, returns undefined (meaning all events are supported)
+ */
+export declare function useSupportedNotificationEvents(): S3EventType[] | undefined;

package/dist/hooks/useSupportedNotificationEvents.js

@@ -0,0 +1,8 @@
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+function useSupportedNotificationEvents() {
+    const { getS3Config } = useDataBrowserContext();
+    if (!getS3Config) return;
+    const config = getS3Config();
+    return config?.s3Capabilities?.supportedNotificationEvents;
+}
+export { useSupportedNotificationEvents };

package/dist/hooks/useTableRowSelection.d.ts

@@ -0,0 +1,9 @@
+export declare function useTableRowSelection<TRow extends {
+    ID?: string;
+}>(tableData: TRow[], autoSelectFirst?: boolean): {
+    selectedId: string | null;
+    onRowSelected: (row: {
+        original: TRow;
+    }) => void;
+    clearSelection: () => void;
+};