@scality/data-browser-library 1.0.0-preview.7 → 1.0.0-preview.9

package/dist/components/buckets/EmptyBucketSummaryList.js

@@ -0,0 +1,140 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { BasicText, Icon, IconHelp, Stack, Text } from "@scality/core-ui";
+import { Table } from "@scality/core-ui/dist/components/tablev2/Tablev2.component";
+import { useMemo } from "react";
+const getUniqueErrorMessages = (errorMessages)=>{
+    const uniqueArray = errorMessages.reduce((acc, message)=>{
+        const existingItem = acc.find((item)=>item.message === message);
+        if (existingItem) existingItem.errorNumbers++;
+        else acc.push({
+            message,
+            errorNumbers: 1
+        });
+        return acc;
+    }, []);
+    return uniqueArray;
+};
+const ErrorsTable = ({ messages })=>{
+    const messagesColumns = [
+        {
+            Header: "Error Message",
+            accessor: "message",
+            cellStyle: {
+                minWidth: "8rem"
+            },
+            Cell ({ value }) {
+                return /*#__PURE__*/ jsx(Text, {
+                    children: value
+                });
+            }
+        },
+        {
+            Header: "Number of errors",
+            accessor: "errorNumbers",
+            cellStyle: {
+                minWidth: "8rem"
+            },
+            Cell ({ value }) {
+                return /*#__PURE__*/ jsx(Text, {
+                    children: value
+                });
+            }
+        }
+    ];
+    const list = getUniqueErrorMessages(messages);
+    const TABLE_HEIGHT = 5 * list.length;
+    return /*#__PURE__*/ jsx(IconHelp, {
+        placement: "top",
+        overlayStyle: {
+            width: "30rem"
+        },
+        tooltipMessage: /*#__PURE__*/ jsx("div", {
+            style: {
+                height: `${TABLE_HEIGHT}rem`
+            },
+            children: /*#__PURE__*/ jsx(Table, {
+                columns: messagesColumns,
+                data: list,
+                children: /*#__PURE__*/ jsx(Table.SingleSelectableContent, {
+                    rowHeight: "h32",
+                    separationLineVariant: "backgroundLevel3"
+                })
+            })
+        })
+    });
+};
+const SummaryCell = (value, isFailed = false, withIcon = false, messages)=>{
+    const text = 1 === value ? "1 object" : `${value} objects`;
+    if (withIcon) return /*#__PURE__*/ jsxs(Stack, {
+        children: [
+            /*#__PURE__*/ jsx(Icon, {
+                name: isFailed ? "Exclamation-circle" : "Check-circle",
+                color: isFailed ? "statusCritical" : "statusHealthy"
+            }),
+            /*#__PURE__*/ jsx(BasicText, {
+                children: text
+            }),
+            messages?.length ? /*#__PURE__*/ jsx(ErrorsTable, {
+                messages: messages
+            }) : null
+        ]
+    });
+    return /*#__PURE__*/ jsx(BasicText, {
+        children: text
+    });
+};
+const useCreateDeleteSummaryColumns = ()=>useMemo(()=>[
+            {
+                Header: "Total attempts",
+                accessor: "attempts",
+                cellStyle: {
+                    minWidth: "12rem"
+                },
+                Cell ({ value }) {
+                    return SummaryCell(value);
+                }
+            },
+            {
+                Header: "Successfully deleted",
+                accessor: "deleted",
+                cellStyle: {
+                    minWidth: "12rem"
+                },
+                Cell ({ value }) {
+                    return SummaryCell(value, false, true);
+                }
+            },
+            {
+                Header: "Deletion failed",
+                accessor: "errors",
+                cellStyle: {
+                    minWidth: "12rem"
+                },
+                Cell ({ value }) {
+                    return SummaryCell(value.nbErrors, true, true, value.messages);
+                }
+            }
+        ], []);
+const EmptyBucketSummaryList = ({ summaryData })=>{
+    const summaryColumns = useCreateDeleteSummaryColumns();
+    return /*#__PURE__*/ jsx("div", {
+        style: {
+            height: "15rem"
+        },
+        children: /*#__PURE__*/ jsx(Table, {
+            columns: summaryColumns,
+            data: summaryData,
+            children: /*#__PURE__*/ jsx("div", {
+                style: {
+                    height: "10rem",
+                    paddingBottom: "5rem"
+                },
+                children: /*#__PURE__*/ jsx(Table.SingleSelectableContent, {
+                    rowHeight: "h40",
+                    separationLineVariant: "backgroundLevel1"
+                })
+            })
+        })
+    });
+};
+export { EmptyBucketSummaryList };

package/dist/components/buckets/notifications/BucketNotificationCreatePage.js

@@ -3,25 +3,25 @@ import { joiResolver } from "@hookform/resolvers/joi";
 import { Form, FormGroup, FormSection, Loader, Stack, Text, useToast } from "@scality/core-ui";
 import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
 import { Button, Input } from "@scality/core-ui/dist/next";
-import { array, object, string } from "joi";
+import joi from "joi";
 import { useCallback } from "react";
 import { FormProvider, useForm } from "react-hook-form";
 import { useNavigate, useParams } from "react-router-dom";
 import { useGetBucketNotification, useSetBucketNotification } from "../../../hooks/index.js";
 import { EventsSection } from "./EventsSection.js";
-const schema = object({
-    ruleName: string().required().messages({
+const schema = joi.object({
+    ruleName: joi.string().required().messages({
         "string.empty": "This field is required"
     }),
-    queueArn: string().required().pattern(/^arn:aws:sqs:[a-z0-9-]+:\d+:.+$/).messages({
+    queueArn: joi.string().required().pattern(/^arn:aws:sqs:[a-z0-9-]+:\d+:.+$/).messages({
         "string.empty": "This field is required",
         "string.pattern.base": "Must be a valid ARN (e.g., arn:aws:sqs:region:account-id:queue-name)"
     }),
-    events: array().min(1).required().messages({
+    events: joi.array().min(1).required().messages({
         "array.min": "At least one event must be selected"
     }),
-    prefix: string().allow("").optional(),
-    suffix: string().allow("").optional()
+    prefix: joi.string().allow("").optional(),
+    suffix: joi.string().allow("").optional()
 });
 function BucketNotificationCreatePage() {
     const { bucketName } = useParams();
@@ -32,7 +32,7 @@ function BucketNotificationCreatePage() {
     });
     const existingRuleNames = existingNotificationData?.QueueConfigurations?.map((config)=>config.Id) || [];
     const dynamicSchema = schema.keys({
-        ruleName: string().required().invalid(...existingRuleNames).messages({
+        ruleName: joi.string().required().invalid(...existingRuleNames).messages({
             "string.empty": "This field is required",
             "any.invalid": "A rule with this name already exists"
         })

package/dist/components/index.d.ts

@@ -1,13 +1,20 @@
 export { DeleteBucketButton } from "./buckets/DeleteBucketButton";
 export { BucketList } from "./buckets/BucketList";
-export { BucketOverview } from "./buckets/BucketOverview";
+export { BucketOverview, BucketOverviewSection, BucketOverviewField, } from "./buckets/BucketOverview";
 export { BucketPage } from "./buckets/BucketPage";
 export { BucketPolicyPage } from "./buckets/BucketPolicyPage";
+export { BucketLifecycleFormPage } from "./buckets/BucketLifecycleFormPage";
+export { BucketReplicationFormPage } from "./buckets/BucketReplicationFormPage";
 export { BucketNotificationCreatePage } from "./buckets/notifications/BucketNotificationCreatePage";
+export { EmptyBucketButton } from "./buckets/EmptyBucketButton";
+export { BucketCreate, baseBucketCreateSchema, bucketNameValidationSchema, bucketErrorMessage, type BucketCreateFormData, } from "./buckets/BucketCreate";
 export { UploadButton } from "./objects/UploadButton";
 export { CreateFolderButton } from "./objects/CreateFolderButton";
 export { ObjectDetails } from "./objects/ObjectDetails";
 export { ObjectList } from "./objects/ObjectList";
 export { ObjectPage } from "./objects/ObjectPage";
+export { ObjectLockSettings } from "./objects/ObjectLock/ObjectLockSettings";
+export { EditRetentionButton } from "./objects/ObjectLock/EditRetentionButton";
 export { MetadataSearch } from "./search/MetadataSearch";
+export { ArrayFieldActions } from "./ui/ArrayFieldActions";
 export { DataBrowserProvider, useDataBrowserContext, useDataBrowserTheme, } from "./providers/DataBrowserProvider";

package/dist/components/index.js

@@ -1,14 +1,21 @@
 import { DeleteBucketButton } from "./buckets/DeleteBucketButton.js";
 import { BucketList } from "./buckets/BucketList.js";
-import { BucketOverview } from "./buckets/BucketOverview.js";
+import { BucketOverview, BucketOverviewField, BucketOverviewSection } from "./buckets/BucketOverview.js";
 import { BucketPage } from "./buckets/BucketPage.js";
 import { BucketPolicyPage } from "./buckets/BucketPolicyPage.js";
+import { BucketLifecycleFormPage } from "./buckets/BucketLifecycleFormPage.js";
+import { BucketReplicationFormPage } from "./buckets/BucketReplicationFormPage.js";
 import { BucketNotificationCreatePage } from "./buckets/notifications/BucketNotificationCreatePage.js";
+import { EmptyBucketButton } from "./buckets/EmptyBucketButton.js";
+import { BucketCreate, baseBucketCreateSchema, bucketErrorMessage, bucketNameValidationSchema } from "./buckets/BucketCreate.js";
 import { UploadButton } from "./objects/UploadButton.js";
 import { CreateFolderButton } from "./objects/CreateFolderButton.js";
 import { ObjectDetails } from "./objects/ObjectDetails/index.js";
 import { ObjectList } from "./objects/ObjectList.js";
 import { ObjectPage } from "./objects/ObjectPage.js";
+import { ObjectLockSettings } from "./objects/ObjectLock/ObjectLockSettings.js";
+import { EditRetentionButton } from "./objects/ObjectLock/EditRetentionButton.js";
 import { MetadataSearch } from "./search/MetadataSearch.js";
+import { ArrayFieldActions } from "./ui/ArrayFieldActions.js";
 import { DataBrowserProvider, useDataBrowserContext, useDataBrowserTheme } from "./providers/DataBrowserProvider.js";
-export { BucketList, BucketNotificationCreatePage, BucketOverview, BucketPage, BucketPolicyPage, CreateFolderButton, DataBrowserProvider, DeleteBucketButton, MetadataSearch, ObjectDetails, ObjectList, ObjectPage, UploadButton, useDataBrowserContext, useDataBrowserTheme };
+export { ArrayFieldActions, BucketCreate, BucketLifecycleFormPage, BucketList, BucketNotificationCreatePage, BucketOverview, BucketOverviewField, BucketOverviewSection, BucketPage, BucketPolicyPage, BucketReplicationFormPage, CreateFolderButton, DataBrowserProvider, DeleteBucketButton, EditRetentionButton, EmptyBucketButton, MetadataSearch, ObjectDetails, ObjectList, ObjectLockSettings, ObjectPage, UploadButton, baseBucketCreateSchema, bucketErrorMessage, bucketNameValidationSchema, useDataBrowserContext, useDataBrowserTheme };

package/dist/components/objects/ObjectLock/EditRetentionButton.d.ts

@@ -0,0 +1,4 @@
+export declare const EditRetentionButton: ({ bucketName }: {
+    bucketName: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default EditRetentionButton;

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

@@ -0,0 +1,32 @@
+import { jsx } from "react/jsx-runtime";
+import { useISVBucketStatus } from "../../../hooks/index.js";
+import { Icon } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+import { useNavigate } from "react-router-dom";
+const EditRetentionButton = ({ bucketName })=>{
+    const navigate = useNavigate();
+    const { isVeeamBucket, isCommvaultBucket, isISVManaged, isLoading } = useISVBucketStatus(bucketName);
+    const tooltipOverlay = isCommvaultBucket ? "Edition is disabled as it is managed by Commvault." : isVeeamBucket ? "Edition is disabled as it is managed by Veeam." : void 0;
+    return /*#__PURE__*/ jsx(Button, {
+        id: "edit-retention-btn",
+        variant: "outline",
+        label: "Edit",
+        "aria-label": "Edit default retention",
+        icon: /*#__PURE__*/ jsx(Icon, {
+            name: "Pencil"
+        }),
+        type: "button",
+        onClick: ()=>{
+            navigate(`/buckets/${bucketName}/objects/object-lock-settings`);
+        },
+        disabled: isISVManaged,
+        ...tooltipOverlay && {
+            tooltip: {
+                overlay: tooltipOverlay
+            }
+        },
+        isLoading: isLoading
+    });
+};
+const ObjectLock_EditRetentionButton = EditRetentionButton;
+export { EditRetentionButton, ObjectLock_EditRetentionButton as default };

package/dist/components/objects/ObjectLock/ObjectLockRetentionSettings.d.ts

@@ -0,0 +1,3 @@
+export default function ObjectLockRetentionSettings({ isEditRetentionSettings, }: {
+    isEditRetentionSettings?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/objects/ObjectLock/ObjectLockRetentionSettings.js

@@ -0,0 +1,211 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Checkbox, FormGroup, FormSection, Stack, Text } from "@scality/core-ui";
+import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
+import { Controller, useFormContext } from "react-hook-form";
+import { Input, Select } from "@scality/core-ui/dist/next";
+function ObjectLockRetentionSettings({ isEditRetentionSettings = false }) {
+    const { control, register, watch, formState: { errors }, setValue } = useFormContext();
+    const isDefaultRetentionEnabled = watch("isDefaultRetentionEnabled");
+    const isObjectLockEnabled = watch("isObjectLockEnabled");
+    const matchVersioning = (checked)=>{
+        if (checked) setValue("isVersioning", true);
+    };
+    return /*#__PURE__*/ jsxs(FormSection, {
+        title: isEditRetentionSettings ? void 0 : {
+            name: "Object-lock"
+        },
+        forceLabelWidth: convertRemToPixels(17.5),
+        children: [
+            /*#__PURE__*/ jsx(FormGroup, {
+                id: "isObjectLockEnabled",
+                label: "Object-lock",
+                content: /*#__PURE__*/ jsx(Checkbox, {
+                    id: "isObjectLockEnabled",
+                    label: isObjectLockEnabled ? "Enabled" : "Disabled",
+                    disabled: isEditRetentionSettings && isObjectLockEnabled,
+                    ...register("isObjectLockEnabled", {
+                        onChange (e) {
+                            matchVersioning(e.target.checked);
+                        }
+                    })
+                }),
+                labelHelpTooltip: /*#__PURE__*/ jsxs("ul", {
+                    children: [
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Permanently allows objects in this bucket to be locked"
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Object-lock option cannot be removed after bucket creation, but you will be able to disable the retention itself on edition."
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Once the bucket is created, you might be blocked from deleting the objects and the bucket."
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Enabling Object-lock automatically activates Versioning for the bucket, and you won’t be able to suspend Versioning."
+                        })
+                    ]
+                }),
+                helpErrorPosition: "bottom",
+                disabled: isEditRetentionSettings
+            }),
+            isObjectLockEnabled && /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "isDefaultRetentionEnabled",
+                        label: "Default Retention",
+                        helpErrorPosition: "bottom",
+                        labelHelpTooltip: isEditRetentionSettings ? /*#__PURE__*/ jsxs("ul", {
+                            children: [
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "These settings apply only to new objects placed into the bucket without any specific object-lock parameters."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "Automatically protect objects put into this bucket from being deleted or overwritten."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "If objects are uploaded into the bucket with their own Retention settings, these will override the Default Retention setting placed on the bucket."
+                                })
+                            ]
+                        }) : /*#__PURE__*/ jsxs("ul", {
+                            children: [
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "Automatically protect objects put into this bucket from being deleted or overwritten."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "These settings apply only to new objects placed into the bucket without any specific object-lock parameters."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "You can activate this option after the bucket creation."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "If objects are uploaded into the bucket with their own Retention settings, these will override the Default Retention setting placed on the bucket."
+                                })
+                            ]
+                        }),
+                        content: /*#__PURE__*/ jsx(Checkbox, {
+                            id: "isDefaultRetentionEnabled",
+                            label: isDefaultRetentionEnabled ? "Active" : "Inactive",
+                            ...register("isDefaultRetentionEnabled")
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "objectlockMode",
+                        label: "Retention mode",
+                        direction: "vertical",
+                        disabled: !isDefaultRetentionEnabled,
+                        helpErrorPosition: "bottom",
+                        content: /*#__PURE__*/ jsx("div", {
+                            style: {
+                                opacity: isDefaultRetentionEnabled ? 1 : 0.5
+                            },
+                            children: /*#__PURE__*/ jsxs(Stack, {
+                                direction: "vertical",
+                                children: [
+                                    /*#__PURE__*/ jsxs(Stack, {
+                                        direction: "vertical",
+                                        children: [
+                                            /*#__PURE__*/ jsxs(Stack, {
+                                                children: [
+                                                    /*#__PURE__*/ jsx("input", {
+                                                        id: "locktype-governance",
+                                                        type: "radio",
+                                                        value: "GOVERNANCE",
+                                                        disabled: !isDefaultRetentionEnabled,
+                                                        ...register("retentionMode")
+                                                    }),
+                                                    /*#__PURE__*/ jsx("label", {
+                                                        htmlFor: "locktype-governance",
+                                                        children: "Governance"
+                                                    })
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ jsx(Text, {
+                                                color: "textSecondary",
+                                                isEmphazed: true,
+                                                variant: "Smaller",
+                                                children: "A user with a specific IAM permissions can overwrite/delete protected object versions during the retention period."
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsxs(Stack, {
+                                        children: [
+                                            /*#__PURE__*/ jsx("input", {
+                                                id: "locktype-compliance",
+                                                type: "radio",
+                                                value: "COMPLIANCE",
+                                                disabled: !isDefaultRetentionEnabled,
+                                                ...register("retentionMode")
+                                            }),
+                                            /*#__PURE__*/ jsx("label", {
+                                                htmlFor: "locktype-compliance",
+                                                children: "Compliance"
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        isEmphazed: true,
+                                        variant: "Smaller",
+                                        children: "No one can overwrite protected object versions during the retention period."
+                                    })
+                                ]
+                            })
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "retentionPeriod",
+                        label: "Retention period",
+                        direction: "horizontal",
+                        helpErrorPosition: "bottom",
+                        help: "Must be a positive whole number.",
+                        error: errors.retentionPeriod?.message,
+                        disabled: !isDefaultRetentionEnabled,
+                        content: /*#__PURE__*/ jsxs(Stack, {
+                            direction: "horizontal",
+                            children: [
+                                /*#__PURE__*/ jsx(Controller, {
+                                    control: control,
+                                    name: "retentionPeriod",
+                                    render: ({ field: { onChange, value: retentionPeriod } })=>/*#__PURE__*/ jsx(Input, {
+                                            id: "retentionPeriod",
+                                            name: "retentionPeriod",
+                                            value: retentionPeriod,
+                                            onChange: (e)=>onChange(e.target.valueAsNumber),
+                                            type: "number",
+                                            step: "1",
+                                            min: "1",
+                                            size: "2/3"
+                                        })
+                                }),
+                                /*#__PURE__*/ jsx(Controller, {
+                                    control: control,
+                                    name: "retentionPeriodFrequencyChoice",
+                                    defaultValue: "DAYS",
+                                    render: ({ field: { onChange, value: retentionPeriodFrequencyChoice } })=>/*#__PURE__*/ jsxs(Select, {
+                                            id: "retentionPeriodFrequencyChoice",
+                                            onChange: onChange,
+                                            placeholder: "retentionPeriodFrequencyChoice",
+                                            value: retentionPeriodFrequencyChoice,
+                                            disabled: !isDefaultRetentionEnabled,
+                                            size: "1/3",
+                                            children: [
+                                                /*#__PURE__*/ jsx(Select.Option, {
+                                                    value: "DAYS",
+                                                    children: "Days"
+                                                }),
+                                                /*#__PURE__*/ jsx(Select.Option, {
+                                                    value: "YEARS",
+                                                    children: "Years"
+                                                })
+                                            ]
+                                        })
+                                })
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { ObjectLockRetentionSettings as default };

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

@@ -0,0 +1,9 @@
+import Joi from "joi";
+export declare const objectLockRetentionSettingsValidationRules: {
+    isObjectLockEnabled: Joi.BooleanSchema<boolean>;
+    isDefaultRetentionEnabled: Joi.BooleanSchema<boolean>;
+    retentionMode: Joi.AlternativesSchema<any>;
+    retentionPeriod: Joi.AlternativesSchema<any>;
+    retentionPeriodFrequencyChoice: Joi.AlternativesSchema<any>;
+};
+export declare function ObjectLockSettings(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,158 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import { FormProvider, useForm } from "react-hook-form";
+import { joiResolver } from "@hookform/resolvers/joi";
+import joi from "joi";
+import { Form, Icon, Loader, Stack, Text, useToast } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+import { useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration } from "../../../hooks/index.js";
+import ObjectLockRetentionSettings from "./ObjectLockRetentionSettings.js";
+const objectLockRetentionSettingsValidationRules = {
+    isObjectLockEnabled: joi.boolean(),
+    isDefaultRetentionEnabled: joi.boolean().default(false),
+    retentionMode: joi.when("isDefaultRetentionEnabled", {
+        is: joi.equal(true),
+        then: joi.string().valid("GOVERNANCE", "COMPLIANCE").required(),
+        otherwise: joi.any()
+    }),
+    retentionPeriod: joi.when("isDefaultRetentionEnabled", {
+        is: joi.equal(true),
+        then: joi.number().integer().min(1).required(),
+        otherwise: joi.any()
+    }),
+    retentionPeriodFrequencyChoice: joi.when("isDefaultRetentionEnabled", {
+        is: joi.equal(true),
+        then: joi.string().valid("DAYS", "YEARS").required(),
+        otherwise: joi.any()
+    })
+};
+const schema = joi.object(objectLockRetentionSettingsValidationRules);
+function ObjectLockSettings() {
+    const { bucketName } = useParams();
+    const navigate = useNavigate();
+    const { showToast } = useToast();
+    const { data: objectLockData, status: objectLockStatus } = useGetBucketObjectLockConfiguration({
+        Bucket: bucketName
+    });
+    const setBucketObjectLockMutation = useSetBucketObjectLockConfiguration();
+    const isObjectLockEnabled = objectLockData?.ObjectLockConfiguration?.ObjectLockEnabled === "Enabled";
+    const defaultRetention = objectLockData?.ObjectLockConfiguration?.Rule?.DefaultRetention;
+    const useFormMethods = useForm({
+        mode: "all",
+        resolver: joiResolver(schema),
+        defaultValues: {
+            isObjectLockEnabled: isObjectLockEnabled,
+            isDefaultRetentionEnabled: !!defaultRetention,
+            retentionMode: defaultRetention?.Mode || "GOVERNANCE",
+            retentionPeriod: defaultRetention?.Days || defaultRetention?.Years || 1,
+            retentionPeriodFrequencyChoice: defaultRetention ? defaultRetention?.Days ? "DAYS" : "YEARS" : "DAYS"
+        }
+    });
+    const { watch, setValue, handleSubmit, formState: { isValid } } = useFormMethods;
+    const isObjectLockEnabledValue = watch("isObjectLockEnabled");
+    const isFormInitialized = useRef(false);
+    useEffect(()=>{
+        if ("success" === objectLockStatus && objectLockData && !isFormInitialized.current) {
+            const isEnabled = objectLockData.ObjectLockConfiguration?.ObjectLockEnabled === "Enabled";
+            const defaultRet = objectLockData.ObjectLockConfiguration?.Rule?.DefaultRetention;
+            setValue("isObjectLockEnabled", isEnabled);
+            setValue("isDefaultRetentionEnabled", !!defaultRet);
+            if (defaultRet) {
+                setValue("retentionMode", defaultRet.Mode);
+                setValue("retentionPeriod", defaultRet.Days || defaultRet.Years || 1);
+                setValue("retentionPeriodFrequencyChoice", defaultRet.Days ? "DAYS" : "YEARS");
+            }
+            isFormInitialized.current = true;
+        }
+    }, [
+        objectLockData,
+        objectLockStatus,
+        setValue
+    ]);
+    const handleCancel = ()=>{
+        navigate(`/buckets/${bucketName}`);
+    };
+    const onSubmit = (data)=>{
+        setBucketObjectLockMutation.mutate({
+            Bucket: bucketName,
+            ObjectLockConfiguration: data.isObjectLockEnabled ? {
+                ObjectLockEnabled: "Enabled",
+                ...data.isDefaultRetentionEnabled && {
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: data.retentionMode,
+                            ..."DAYS" === data.retentionPeriodFrequencyChoice ? {
+                                Days: data.retentionPeriod
+                            } : {
+                                Years: data.retentionPeriod
+                            }
+                        }
+                    }
+                }
+            } : void 0
+        }, {
+            onSuccess: ()=>{
+                showToast({
+                    open: true,
+                    message: "Object Lock settings saved successfully",
+                    status: "success"
+                });
+                navigate(`/buckets/${bucketName}`);
+            },
+            onError: (error)=>{
+                const errorMessage = error instanceof Error ? error.message : "Failed to save Object Lock settings";
+                showToast({
+                    open: true,
+                    message: errorMessage,
+                    status: "error"
+                });
+            }
+        });
+    };
+    if ("pending" === objectLockStatus) return /*#__PURE__*/ jsx(Loader, {
+        centered: true,
+        children: /*#__PURE__*/ jsx(Text, {
+            children: "Loading retention settings..."
+        })
+    });
+    return /*#__PURE__*/ jsx(FormProvider, {
+        ...useFormMethods,
+        children: /*#__PURE__*/ jsx(Form, {
+            onSubmit: handleSubmit(onSubmit),
+            requireMode: "partial",
+            layout: {
+                kind: "page",
+                title: "Object-lock settings"
+            },
+            rightActions: /*#__PURE__*/ jsxs(Stack, {
+                gap: "r16",
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        id: "cancel-btn",
+                        variant: "outline",
+                        onClick: handleCancel,
+                        type: "button",
+                        label: "Cancel",
+                        disabled: setBucketObjectLockMutation.isPending
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        disabled: !isValid || !isObjectLockEnabledValue || setBucketObjectLockMutation.isPending,
+                        id: "edit-retention-setting-btn",
+                        type: "submit",
+                        variant: "primary",
+                        label: "Save",
+                        icon: /*#__PURE__*/ jsx(Icon, {
+                            name: "Save"
+                        }),
+                        isLoading: setBucketObjectLockMutation.isPending
+                    })
+                ]
+            }),
+            children: /*#__PURE__*/ jsx(ObjectLockRetentionSettings, {
+                isEditRetentionSettings: true
+            })
+        })
+    });
+}
+export { ObjectLockSettings, objectLockRetentionSettingsValidationRules };