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

package/dist/components/objects/ObjectLock/__tests__/EditRetentionButton.test.js

@@ -0,0 +1,204 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { MemoryRouter, useNavigate } from "react-router";
+import { useISVBucketStatus } from "../../../../hooks/index.js";
+import { createTestWrapper } from "../../../../test/testUtils.js";
+import { EditRetentionButton } from "../EditRetentionButton.js";
+jest.mock('../../../../hooks');
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
+        useNavigate: jest.fn()
+    }));
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
+const mockUseNavigate = jest.mocked(useNavigate);
+const renderEditRetentionButton = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    const mockNavigate = jest.fn();
+    mockUseNavigate.mockReturnValue(mockNavigate);
+    const result = render(/*#__PURE__*/ jsx(MemoryRouter, {
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(EditRetentionButton, {
+                bucketName: "test-bucket",
+                ...props
+            })
+        })
+    }));
+    return {
+        ...result,
+        navigate: mockNavigate
+    };
+};
+beforeEach(()=>{
+    jest.clearAllMocks();
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+});
+it('renders edit button', ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeInTheDocument();
+});
+it('navigates to object lock settings page when clicked', ()=>{
+    const { navigate } = renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    fireEvent.click(editButton);
+    expect(navigate).toHaveBeenCalledWith('/buckets/test-bucket/objects/object-lock-settings');
+});
+it('navigates with correct bucket name', ()=>{
+    const { navigate } = renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    fireEvent.click(editButton);
+    expect(navigate).toHaveBeenCalledWith('/buckets/test-bucket/objects/object-lock-settings');
+});
+it('is enabled for regular buckets without ISV tags', ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it('is disabled for Veeam Backup & Replication buckets', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: 'Veeam',
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it('is disabled for Veeam Office 365 v6/v7 buckets', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: 'Veeam',
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it('is disabled for Veeam Office 365 v8+ buckets', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: 'Veeam',
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it('is disabled for Commvault buckets', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: true,
+        isISVManaged: true,
+        isvApplication: 'Commvault',
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it('is disabled for ISV buckets tagged as Veeam Backup for Microsoft 365', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: 'Veeam',
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it('is disabled for ISV buckets tagged as Veeam Backup & Replication', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: 'Veeam',
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it('handles missing bucket tags gracefully', ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it('handles empty TagSet gracefully', ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it('is enabled for buckets with non-ISV tags', ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it('handles bucket tagging query error gracefully', ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it('shows loading state when fetching bucket tags', ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: true,
+        bucketTagsStatus: 'pending'
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole('button', {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeInTheDocument();
+});

package/dist/components/objects/ObjectLock/__tests__/ObjectLockSettings.test.d.ts

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

package/dist/components/objects/ObjectLock/__tests__/ObjectLockSettings.test.js

@@ -0,0 +1,374 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { MemoryRouter, Route, Routes } from "react-router";
+import { useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration } from "../../../../hooks/index.js";
+import { createTestWrapper } from "../../../../test/testUtils.js";
+import { ObjectLockSettings } from "../ObjectLockSettings.js";
+jest.mock('../../../../hooks', ()=>({
+        useGetBucketObjectLockConfiguration: jest.fn(),
+        useSetBucketObjectLockConfiguration: jest.fn()
+    }));
+const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
+const mockUseSetBucketObjectLockConfiguration = jest.mocked(useSetBucketObjectLockConfiguration);
+const mockNavigate = jest.fn();
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
+        useNavigate: ()=>mockNavigate
+    }));
+const renderObjectLockSettings = (bucketName = 'test-bucket')=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        initialEntries: [
+            `/buckets/${bucketName}/objects/settings`
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(Routes, {
+                children: /*#__PURE__*/ jsx(Route, {
+                    path: "/buckets/:bucketName/objects/settings",
+                    element: /*#__PURE__*/ jsx(ObjectLockSettings, {})
+                })
+            })
+        })
+    }));
+};
+describe('ObjectLockSettings', ()=>{
+    const mockMutate = jest.fn();
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: void 0,
+            status: 'success'
+        });
+        mockUseSetBucketObjectLockConfiguration.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+    });
+    it('displays loading state while fetching bucket configuration', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: void 0,
+            status: 'pending'
+        });
+        renderObjectLockSettings();
+        expect(screen.getByText('Loading retention settings...')).toBeInTheDocument();
+    });
+    it('renders form with Object Lock checkbox', async ()=>{
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText('Object-lock settings')).toBeInTheDocument();
+        });
+        expect(screen.getByLabelText(/object-lock/i)).toBeInTheDocument();
+    });
+    it('disables save button when Object Lock is not enabled', async ()=>{
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            expect(saveButton).toBeDisabled();
+        });
+    });
+    it('shows Default Retention fields when Object Lock is enabled', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
+            expect(screen.getByText('Retention mode')).toBeInTheDocument();
+            expect(screen.getByText('Retention period')).toBeInTheDocument();
+        }, {
+            timeout: 3000
+        });
+    });
+    it('enables save button when Object Lock is enabled', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            expect(saveButton).toBeEnabled();
+        }, {
+            timeout: 3000
+        });
+    });
+    it('enables retention fields when Default Retention is checked', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        expect(defaultRetentionCheckbox).not.toBeChecked();
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const governanceRadio = screen.getByLabelText(/governance/i);
+            expect(governanceRadio).not.toBeDisabled();
+        }, {
+            timeout: 3000
+        });
+    });
+    it('disables retention fields when Default Retention is unchecked', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'GOVERNANCE',
+                            Days: 30
+                        }
+                    }
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+            fireEvent.click(defaultRetentionCheckbox);
+        });
+        await waitFor(()=>{
+            const governanceRadio = screen.getByLabelText(/governance/i);
+            expect(governanceRadio).toBeDisabled();
+        });
+    });
+    it('shows validation error when retention period is invalid', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+            expect(retentionPeriodInput).toBeInTheDocument();
+        });
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        await user_event.clear(retentionPeriodInput);
+        await user_event.type(retentionPeriodInput, '0');
+        await waitFor(()=>{
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            expect(saveButton).toBeDisabled();
+        }, {
+            timeout: 3000
+        });
+    });
+    it('saves Object Lock configuration with Default Retention and navigates on success', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+            expect(retentionPeriodInput).toBeInTheDocument();
+        });
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        await user_event.clear(retentionPeriodInput);
+        await user_event.type(retentionPeriodInput, '30');
+        const governanceRadio = screen.getByLabelText(/governance/i);
+        fireEvent.click(governanceRadio);
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole('button', {
+            name: /save/i
+        });
+        await waitFor(()=>expect(saveButton).toBeEnabled(), {
+            timeout: 3000
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalled();
+            const callArgs = mockMutate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe('test-bucket');
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe('Enabled');
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe('GOVERNANCE');
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Days || callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Years).toBe(30);
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
+        });
+    });
+    it('saves Object Lock configuration with Years frequency', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+            expect(retentionPeriodInput).toBeInTheDocument();
+        });
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        await user_event.clear(retentionPeriodInput);
+        await user_event.type(retentionPeriodInput, '2');
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole('button', {
+            name: /save/i
+        });
+        await waitFor(()=>expect(saveButton).toBeEnabled(), {
+            timeout: 3000
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalled();
+            const callArgs = mockMutate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe('test-bucket');
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe('Enabled');
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe('GOVERNANCE');
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Days || callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Years).toBe(2);
+        });
+    });
+    it('saves Object Lock configuration without Default Retention', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            expect(saveButton).toBeEnabled();
+        }, {
+            timeout: 3000
+        });
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole('button', {
+            name: /save/i
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalled();
+            const callArgs = mockMutate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe('test-bucket');
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe('Enabled');
+            expect(callArgs.ObjectLockConfiguration.Rule).toBeUndefined();
+        });
+    });
+    it('displays error toast when save fails', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            expect(saveButton).toBeEnabled();
+        }, {
+            timeout: 3000
+        });
+        const error = new Error('Access Denied');
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onError?.(error);
+        });
+        const saveButton = screen.getByRole('button', {
+            name: /save/i
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+    });
+    it('navigates back when cancel button is clicked', async ()=>{
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+        });
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
+    });
+    it('populates form with existing bucket configuration', async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'COMPLIANCE',
+                            Days: 60
+                        }
+                    }
+                }
+            },
+            status: 'success'
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const objectLockCheckbox = screen.getByLabelText(/object-lock/i);
+            expect(objectLockCheckbox).toBeChecked();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        expect(defaultRetentionCheckbox).toBeChecked();
+        const complianceRadio = screen.getByLabelText(/compliance/i);
+        expect(complianceRadio).toBeChecked();
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        expect(retentionPeriodInput).toHaveValue(60);
+    });
+});

package/dist/components/objects/ObjectPage.js

@@ -1,18 +1,19 @@
 import { jsx } from "react/jsx-runtime";
-import { useNavigate, useParams, useSearchParams } from "react-router-dom";
 import { useCallback, useState } from "react";
-import { ObjectList } from "./ObjectList.js";
-import { ObjectDetails } from "./ObjectDetails/index.js";
+import { useParams, useSearchParams } from "react-router";
+import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
 import { BrowserPageLayout } from "../layouts/BrowserPageLayout.js";
+import { ObjectDetails } from "./ObjectDetails/index.js";
+import { ObjectList } from "./ObjectList.js";
 const ObjectPage = ()=>{
     const { bucketName } = useParams();
-    const navigate = useNavigate();
+    const navigate = useDataBrowserNavigate();
     const [searchParams] = useSearchParams();
     const [item, setItem] = useState(null);
-    const prefix = searchParams.get("prefix") || "";
+    const prefix = searchParams.get('prefix') || '';
     const handlePrefixChange = useCallback((newPrefix)=>{
         const newSearchParams = new URLSearchParams(searchParams);
-        newSearchParams.set("prefix", newPrefix);
+        newSearchParams.set('prefix', newPrefix);
         setItem(null);
         navigate(`?${newSearchParams.toString()}`, {
             replace: true
@@ -28,6 +29,7 @@ const ObjectPage = ()=>{
         setItem(object);
     };
     return /*#__PURE__*/ jsx(BrowserPageLayout, {
+        iconName: "Bucket",
         title: bucketName,
         leftPanel: /*#__PURE__*/ jsx(ObjectList, {
             bucketName: bucketName,
@@ -35,9 +37,11 @@ const ObjectPage = ()=>{
             onObjectSelect: handleObjectSelect,
             onPrefixChange: handlePrefixChange
         }),
-        rightPanel: item ? /*#__PURE__*/ jsx(ObjectDetails, {
+        rightPanel: /*#__PURE__*/ jsx(ObjectDetails, {
             item: item
-        }) : "Select an object to view details"
+        }),
+        withArrowNavigation: true,
+        arrowNavigationPath: `/buckets/${bucketName}`
     });
 };
 export { ObjectPage };

package/dist/components/objects/UploadButton.d.ts

@@ -1,5 +1,5 @@
-import React from "react";
-import type { PutObjectCommandInput } from "@aws-sdk/client-s3";
+import type { PutObjectCommandInput } from '@aws-sdk/client-s3';
+import type React from 'react';
 interface UploadButtonProps {
     /**
      * The S3 bucket name where files will be uploaded
@@ -16,7 +16,7 @@ interface UploadButtonProps {
     /**
      * Button variant
      */
-    variant?: "primary" | "secondary" | "outline";
+    variant?: 'primary' | 'secondary' | 'outline';
     /**
      * Upload options to configure metadata, encryption, etc.
      */