@codebit-programando-solucoes/codebit-web-antd 1.1.5 → 1.1.16

package/dist/index.cjs

@@ -0,0 +1,1690 @@
+/*! For license information please see index.cjs.LICENSE.txt */
+"use strict";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/react@19.2.0/node_modules/react/cjs/react-jsx-runtime.development.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        /**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "production" !== process.env.NODE_ENV && function() {
+            function getComponentNameFromType(type) {
+                if (null == type) return null;
+                if ("function" == typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+                if ("string" == typeof type) return type;
+                switch(type){
+                    case REACT_FRAGMENT_TYPE:
+                        return "Fragment";
+                    case REACT_PROFILER_TYPE:
+                        return "Profiler";
+                    case REACT_STRICT_MODE_TYPE:
+                        return "StrictMode";
+                    case REACT_SUSPENSE_TYPE:
+                        return "Suspense";
+                    case REACT_SUSPENSE_LIST_TYPE:
+                        return "SuspenseList";
+                    case REACT_ACTIVITY_TYPE:
+                        return "Activity";
+                }
+                if ("object" == typeof type) switch("number" == typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof){
+                    case REACT_PORTAL_TYPE:
+                        return "Portal";
+                    case REACT_CONTEXT_TYPE:
+                        return type.displayName || "Context";
+                    case REACT_CONSUMER_TYPE:
+                        return (type._context.displayName || "Context") + ".Consumer";
+                    case REACT_FORWARD_REF_TYPE:
+                        var innerType = type.render;
+                        type = type.displayName;
+                        type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+                        return type;
+                    case REACT_MEMO_TYPE:
+                        return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+                    case REACT_LAZY_TYPE:
+                        innerType = type._payload;
+                        type = type._init;
+                        try {
+                            return getComponentNameFromType(type(innerType));
+                        } catch (x) {}
+                }
+                return null;
+            }
+            function testStringCoercion(value) {
+                return "" + value;
+            }
+            function checkKeyStringCoercion(value) {
+                try {
+                    testStringCoercion(value);
+                    var JSCompiler_inline_result = !1;
+                } catch (e) {
+                    JSCompiler_inline_result = !0;
+                }
+                if (JSCompiler_inline_result) {
+                    JSCompiler_inline_result = console;
+                    var JSCompiler_temp_const = JSCompiler_inline_result.error;
+                    var JSCompiler_inline_result$jscomp$0 = "function" == typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+                    JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+                    return testStringCoercion(value);
+                }
+            }
+            function getTaskName(type) {
+                if (type === REACT_FRAGMENT_TYPE) return "<>";
+                if ("object" == typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+                try {
+                    var name = getComponentNameFromType(type);
+                    return name ? "<" + name + ">" : "<...>";
+                } catch (x) {
+                    return "<...>";
+                }
+            }
+            function getOwner() {
+                var dispatcher = ReactSharedInternals.A;
+                return null === dispatcher ? null : dispatcher.getOwner();
+            }
+            function UnknownOwner() {
+                return Error("react-stack-top-frame");
+            }
+            function hasValidKey(config) {
+                if (hasOwnProperty.call(config, "key")) {
+                    var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+                    if (getter && getter.isReactWarning) return !1;
+                }
+                return void 0 !== config.key;
+            }
+            function defineKeyPropWarningGetter(props, displayName) {
+                function warnAboutAccessingKey() {
+                    specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+                }
+                warnAboutAccessingKey.isReactWarning = !0;
+                Object.defineProperty(props, "key", {
+                    get: warnAboutAccessingKey,
+                    configurable: !0
+                });
+            }
+            function elementRefGetterWithDeprecationWarning() {
+                var componentName = getComponentNameFromType(this.type);
+                didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+                componentName = this.props.ref;
+                return void 0 !== componentName ? componentName : null;
+            }
+            function ReactElement(type, key, props, owner, debugStack, debugTask) {
+                var refProp = props.ref;
+                type = {
+                    $$typeof: REACT_ELEMENT_TYPE,
+                    type: type,
+                    key: key,
+                    props: props,
+                    _owner: owner
+                };
+                null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+                    enumerable: !1,
+                    get: elementRefGetterWithDeprecationWarning
+                }) : Object.defineProperty(type, "ref", {
+                    enumerable: !1,
+                    value: null
+                });
+                type._store = {};
+                Object.defineProperty(type._store, "validated", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: 0
+                });
+                Object.defineProperty(type, "_debugInfo", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: null
+                });
+                Object.defineProperty(type, "_debugStack", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: debugStack
+                });
+                Object.defineProperty(type, "_debugTask", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: debugTask
+                });
+                Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+                return type;
+            }
+            function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+                var children = config.children;
+                if (void 0 !== children) if (isStaticChildren) if (isArrayImpl(children)) {
+                    for(isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)validateChildKeys(children[isStaticChildren]);
+                    Object.freeze && Object.freeze(children);
+                } else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+                else validateChildKeys(children);
+                if (hasOwnProperty.call(config, "key")) {
+                    children = getComponentNameFromType(type);
+                    var keys = Object.keys(config).filter(function(k) {
+                        return "key" !== k;
+                    });
+                    isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+                    didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+                }
+                children = null;
+                void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+                hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+                if ("key" in config) {
+                    maybeKey = {};
+                    for(var propName in config)"key" !== propName && (maybeKey[propName] = config[propName]);
+                } else maybeKey = config;
+                children && defineKeyPropWarningGetter(maybeKey, "function" == typeof type ? type.displayName || type.name || "Unknown" : type);
+                return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+            }
+            function validateChildKeys(node) {
+                isValidElement(node) ? node._store && (node._store.validated = 1) : "object" == typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+            }
+            function isValidElement(object) {
+                return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+            }
+            var React = __webpack_require__("react"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+                return null;
+            };
+            React = {
+                react_stack_bottom_frame: function(callStackForError) {
+                    return callStackForError();
+                }
+            };
+            var specialPropKeyWarningShown;
+            var didWarnAboutElementRef = {};
+            var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+            var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+            var didWarnAboutKeySpread = {};
+            exports1.Fragment = REACT_FRAGMENT_TYPE;
+            exports1.jsx = function(type, config, maybeKey) {
+                var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+                return jsxDEVImpl(type, config, maybeKey, !1, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+            };
+            exports1.jsxs = function(type, config, maybeKey) {
+                var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+                return jsxDEVImpl(type, config, maybeKey, !0, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+            };
+        }();
+    },
+    "../../node_modules/.pnpm/react@19.2.0/node_modules/react/cjs/react-jsx-runtime.production.js": function(__unused_webpack_module, exports1) {
+        /**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+        function jsxProd(type, config, maybeKey) {
+            var key = null;
+            void 0 !== maybeKey && (key = "" + maybeKey);
+            void 0 !== config.key && (key = "" + config.key);
+            if ("key" in config) {
+                maybeKey = {};
+                for(var propName in config)"key" !== propName && (maybeKey[propName] = config[propName]);
+            } else maybeKey = config;
+            config = maybeKey.ref;
+            return {
+                $$typeof: REACT_ELEMENT_TYPE,
+                type: type,
+                key: key,
+                ref: void 0 !== config ? config : null,
+                props: maybeKey
+            };
+        }
+        exports1.Fragment = REACT_FRAGMENT_TYPE;
+        exports1.jsx = jsxProd;
+        exports1.jsxs = jsxProd;
+    },
+    "../../node_modules/.pnpm/react@19.2.0/node_modules/react/jsx-runtime.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        if ('production' === process.env.NODE_ENV) module.exports = __webpack_require__("../../node_modules/.pnpm/react@19.2.0/node_modules/react/cjs/react-jsx-runtime.production.js");
+        else module.exports = __webpack_require__("../../node_modules/.pnpm/react@19.2.0/node_modules/react/cjs/react-jsx-runtime.development.js");
+    },
+    react: function(module) {
+        module.exports = require("react");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        TableContainer: ()=>TableContainer,
+        CssTokenBridge: ()=>CssTokenBridge,
+        LoggedMainContainer: ()=>LoggedMainContainer,
+        Login: ()=>Login,
+        ErrorRetry: ()=>ErrorRetry,
+        CodebitConfigContext: ()=>CodebitConfigContext,
+        ListCard: ()=>ListCard,
+        ForgotPassword: ()=>ForgotPassword,
+        LoginContainer: ()=>LoginContainer,
+        CodebitTheme: ()=>CodebitTheme,
+        LocalLoginRecoveryPasswordResult: ()=>LocalLoginRecoveryPasswordResult,
+        FilterContainer: ()=>FilterContainer,
+        HandleError: ()=>HandleError,
+        LocalLoginAuthenticationResult: ()=>LocalLoginAuthenticationResult,
+        CodebitConfigProvider: ()=>CodebitConfigProvider,
+        ThemeToggle: ()=>ThemeToggle
+    });
+    var jsx_runtime = __webpack_require__("../../node_modules/.pnpm/react@19.2.0/node_modules/react/jsx-runtime.js");
+    const icons_namespaceObject = require("@ant-design/icons");
+    const external_antd_namespaceObject = require("antd");
+    const external_prop_types_namespaceObject = require("prop-types");
+    var external_prop_types_default = /*#__PURE__*/ __webpack_require__.n(external_prop_types_namespaceObject);
+    var external_react_ = __webpack_require__("react");
+    const external_react_router_namespaceObject = require("react-router");
+    const external_i18next_namespaceObject = require("i18next");
+    const external_react_i18next_namespaceObject = require("react-i18next");
+    const pt = {
+        codebitWebAntd: {
+            LoggedMainContainer: {
+                theme: 'Tema',
+                logout: 'Sair',
+                version: 'Versão'
+            },
+            HandleError: {
+                notFoundTitle: 'Página não encontrada',
+                forbiddenTitle: 'Acesso negado',
+                internalTitle: 'Erro interno',
+                genericTitle: 'Erro inesperado',
+                notFoundMessage: 'A página que você estava procurando não existe.',
+                forbiddenMessage: 'Você não tem permissão para acessar esta página.',
+                internalMessage: 'Ocorreu um erro interno no servidor.',
+                genericMessage: 'Ocorreu um erro inesperado.',
+                backHome: 'Voltar para página inicial'
+            },
+            ErrorRetry: {
+                defaultError: 'Erro ao carregar',
+                retryButton: 'Tentar novamente',
+                reloadPageButton: 'Recarregar página',
+                networkError: 'Falha de conexão',
+                timeoutError: 'Servidor demorou para responder',
+                badRequestError: 'Requisição inválida',
+                forbiddenError: 'Recurso negado pelo servidor',
+                notFoundError: 'Recurso não encontrado pelo servidor',
+                internalServerError: 'Erro interno no servidor',
+                sessionExpiredError: 'Sessão expirada'
+            },
+            Login: {
+                loginTitle: 'Entrar',
+                googleLogin: 'Entrar com o Google',
+                emailLabel: 'E-mail',
+                passwordLabel: 'Senha',
+                emailPlaceholder: 'Digite seu e-mail',
+                passwordPlaceholder: 'Digite sua senha',
+                forgotPassword: 'Esqueceu sua senha?',
+                loginButton: 'Entrar',
+                emailRequired: 'Por favor, insira seu e-mail!',
+                emailInvalid: 'Por favor, insira um e-mail válido!',
+                passwordRequired: 'Por favor, insira sua senha!',
+                separator: 'ou',
+                errorTitle: 'Erro ao autenticar',
+                genericError: 'Ocorreu um erro. Por favor, tente novamente.',
+                invalidPassword: 'A senha está incorreta.',
+                invalidEmailOrPassword: 'O e-mail ou senha estão incorretos.',
+                userDisabled: 'Sua conta foi desativada. Por favor, entre em contato com o suporte.',
+                authenticationFailed: 'Autenticação falhou'
+            },
+            ForgotPassword: {
+                title: 'Redefinição de senha',
+                instructions: 'Informe seu e-mail para receber as instruções de recuperação de senha.',
+                emailRequired: 'Por favor, insira seu e-mail!',
+                emailInvalid: 'Por favor, insira um e-mail válido!',
+                emailPlaceholder: 'E-mail',
+                submitButton: 'Recuperar senha',
+                backToLogin: 'Voltar para o login',
+                resetSuccessMessage: 'Se o endereço informado estiver correto, enviaremos um e-mail com instruções para redefinição de senha.'
+            },
+            ChangePassword: {
+                title: 'Alterar senha',
+                passwordInstructions: 'Defina uma nova senha para realizar seu login.',
+                newPassword: 'Nova senha',
+                confirmPassword: 'Confirmar senha',
+                submit: 'Enviar',
+                backToLogin: 'Voltar para o login',
+                passwordRequired: 'Por favor, insira sua nova senha!',
+                passwordLength: '8 caracteres',
+                passwordUpperCase: 'uma letra maiúscula',
+                passwordLowerCase: 'uma letra minúscula',
+                passwordNumbers: 'um número',
+                passwordSpecialChars: 'um caractere especial (!@#$%^&*)',
+                passwordWeak: 'Senha fraca: Deve ter pelo menos {requirements}',
+                passwordsNotMatch: 'As senhas digitadas não coincidem!',
+                tokenInvalidTitle: 'Token inválido',
+                tokenInvalidOrExpired: 'O token informado é inválido ou está expirado. Inicie o processo de recuperação de senha e tente novamente.',
+                passwordChangedSuccess: 'A senha foi alterada com sucesso. Você será redirecionado ao login após fechar essa janela.',
+                tokenInvalidRecovery: 'O token informado é inválido ou está expirado. Inicie o processo de recuperação de senha novamente.'
+            },
+            LoginContainer: {
+                theme: 'Tema',
+                signIn: 'Entrar'
+            },
+            NotFound: {
+                pageNotFound: 'Página não encontrada',
+                sorryTheSearchPageDoesntExistOrRemoved: 'Desculpe, a página que você está procurando não existe ou foi removida.',
+                back: 'Voltar',
+                company: '© 2025 Codebit - Todos os direitos reservados'
+            },
+            ListCard: {
+                clearFilters: 'Limpar filtros'
+            },
+            Common: {
+                ok: 'Ok',
+                close: 'Fechar',
+                invalidEmail: 'O e-mail é inválido ou não está registrado.',
+                recaptchaFailed: 'Validação reCAPTCHA falhou. Por favor, tente novamente.'
+            }
+        }
+    };
+    const en = {
+        codebitWebAntd: {
+            LoggedMainContainer: {
+                theme: 'Theme',
+                logout: 'Logout',
+                version: 'Version'
+            },
+            HandleError: {
+                notFoundTitle: 'Page not found',
+                forbiddenTitle: 'Access denied',
+                internalTitle: 'Internal error',
+                genericTitle: 'Unexpected error',
+                notFoundMessage: 'The page you were looking for does not exist.',
+                forbiddenMessage: 'You do not have permission to access this page.',
+                internalMessage: 'An internal server error occurred.',
+                genericMessage: 'An unexpected error occurred.',
+                backHome: 'Back to home'
+            },
+            ErrorRetry: {
+                defaultError: 'Failed to load',
+                retryButton: 'Try again',
+                reloadPageButton: 'Reload page',
+                networkError: 'Connection failed',
+                timeoutError: 'Server took too long to respond',
+                badRequestError: 'Invalid request',
+                forbiddenError: 'Resource denied by server',
+                notFoundError: 'Resource not found by server',
+                internalServerError: 'Internal server error',
+                sessionExpiredError: 'Session expired'
+            },
+            Login: {
+                loginTitle: 'Login',
+                googleLogin: 'Login with Google',
+                emailLabel: 'Email',
+                passwordLabel: 'Password',
+                emailPlaceholder: 'Enter your email',
+                passwordPlaceholder: 'Enter your password',
+                forgotPassword: 'Forgot password?',
+                loginButton: 'Login',
+                emailRequired: 'Please enter your email!',
+                emailInvalid: 'Please enter a valid email!',
+                passwordRequired: 'Please enter your password!',
+                separator: 'or',
+                errorTitle: 'Login Error',
+                invalidPassword: 'The password is incorrect.',
+                invalidEmailOrPassword: 'The email or password is incorrect.',
+                authenticationFailed: 'Authentication failed',
+                userDisabled: 'Your account has been disabled. Please contact support.'
+            },
+            ForgotPassword: {
+                title: 'Password reset',
+                instructions: 'Enter your email to receive password reset instructions.',
+                emailRequired: 'Please enter your email!',
+                emailInvalid: 'Please enter a valid email!',
+                emailPlaceholder: 'Email',
+                submitButton: 'Reset password',
+                backToLogin: 'Back to login',
+                resetSuccessMessage: 'If the provided email is correct, we will send you an email with instructions to reset your password.'
+            },
+            ChangePassword: {
+                title: 'Change password',
+                passwordInstructions: 'Set a new password to log in.',
+                newPassword: 'New password',
+                confirmPassword: 'Confirm password',
+                submit: 'Send',
+                backToLogin: 'Back to login',
+                passwordRequired: 'Please enter your new password!',
+                passwordLength: '8 characters',
+                passwordUpperCase: 'an uppercase letter',
+                passwordLowerCase: 'a lowercase letter',
+                passwordNumbers: 'a number',
+                passwordSpecialChars: 'a special character (!@#$%^&*)',
+                passwordWeak: 'Weak password: Must have at least {requirements}',
+                passwordsNotMatch: 'The passwords do not match!',
+                tokenInvalidTitle: 'Invalid Token',
+                tokenInvalidOrExpired: 'The provided token is invalid or expired. Start the password recovery process and try again.',
+                passwordChangedSuccess: 'Your password has been changed successfully. You will be redirected to the login after closing this window.',
+                tokenInvalidRecovery: 'The provided token is invalid or expired. Start the password recovery process again.'
+            },
+            LoginContainer: {
+                theme: 'Theme',
+                signIn: 'Sign in'
+            },
+            NotFound: {
+                pageNotFound: 'Page not found',
+                sorryTheSearchPageDoesntExistOrRemoved: 'Sorry, the page you are looking for does not exist or has been removed.',
+                back: 'Back',
+                company: '© 2025 Codebit - All rights reserved'
+            },
+            ListCard: {
+                clearFilters: 'Clear filters'
+            },
+            Common: {
+                ok: 'Ok',
+                close: 'Close',
+                genericError: 'An error occurred. Please try again.',
+                invalidEmail: 'The email address is invalid or not registered.',
+                recaptchaFailed: 'reCAPTCHA validation failed. Please try again.'
+            }
+        }
+    };
+    const i18nLib = external_i18next_namespaceObject.createInstance();
+    i18nLib.use(external_react_i18next_namespaceObject.initReactI18next).init({
+        resources: {
+            pt: pt,
+            en: en
+        },
+        lng: 'pt',
+        fallbackLng: 'pt',
+        defaultNS: 'codebitWebAntd',
+        ns: [
+            'codebitWebAntd'
+        ],
+        interpolation: {
+            escapeValue: false
+        }
+    });
+    const i18n = i18nLib;
+    const CodebitConfigContext = /*#__PURE__*/ (0, external_react_.createContext)(null);
+    function CodebitConfigProvider({ children, menuItems, user, onLogout, version = '1.0', showVersion = true, secondarySidebar, secondarySidebarWidth = 280, storeThemeInLocalStorage = true }) {
+        const getSystemTheme = ()=>globalThis.matchMedia?.('(prefers-color-scheme: dark)')?.matches ?? false;
+        const [isDarkMode, setIsDarkMode] = (0, external_react_.useState)(()=>{
+            if (storeThemeInLocalStorage) {
+                const savedTheme = localStorage.getItem('theme');
+                if (null !== savedTheme) return 'dark' === savedTheme;
+            }
+            return getSystemTheme();
+        });
+        (0, external_react_.useEffect)(()=>{
+            const mediaQuery = globalThis.matchMedia('(prefers-color-scheme: dark)');
+            const handleThemeChange = (e)=>{
+                if (!storeThemeInLocalStorage) return void setIsDarkMode(e.matches);
+                const savedTheme = localStorage.getItem('theme');
+                if (null === savedTheme) setIsDarkMode(e.matches);
+            };
+            mediaQuery.addEventListener('change', handleThemeChange);
+            return ()=>{
+                mediaQuery.removeEventListener('change', handleThemeChange);
+            };
+        }, [
+            storeThemeInLocalStorage
+        ]);
+        const toggleTheme = ()=>{
+            const newTheme = !isDarkMode;
+            setIsDarkMode(newTheme);
+            if (storeThemeInLocalStorage) localStorage.setItem('theme', newTheme ? 'dark' : 'light');
+        };
+        const resetToSystemTheme = ()=>{
+            if (storeThemeInLocalStorage) localStorage.removeItem('theme');
+            setIsDarkMode(getSystemTheme());
+        };
+        const contextValue = (0, external_react_.useMemo)(()=>({
+                menuItems,
+                user,
+                onLogout,
+                version,
+                showVersion,
+                i18n: i18n,
+                secondarySidebar,
+                secondarySidebarWidth,
+                isDarkMode,
+                setIsDarkMode,
+                toggleTheme,
+                resetToSystemTheme
+            }), [
+            menuItems,
+            user,
+            onLogout,
+            version,
+            showVersion,
+            secondarySidebar,
+            secondarySidebarWidth,
+            isDarkMode,
+            storeThemeInLocalStorage
+        ]);
+        return /*#__PURE__*/ (0, jsx_runtime.jsxs)(CodebitConfigContext.Provider, {
+            value: contextValue,
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(CssTokenBridge, {}),
+                children
+            ]
+        });
+    }
+    CodebitConfigProvider.propTypes = {
+        children: external_prop_types_default().node.isRequired,
+        menuItems: external_prop_types_default().arrayOf(external_prop_types_default().shape({
+            key: external_prop_types_default().string.isRequired,
+            icon: external_prop_types_default().node,
+            label: external_prop_types_default().string.isRequired,
+            roles: external_prop_types_default().arrayOf(external_prop_types_default().string)
+        })).isRequired,
+        user: external_prop_types_default().shape({
+            name: external_prop_types_default().string.isRequired,
+            email: external_prop_types_default().string.isRequired,
+            id: external_prop_types_default().string.isRequired,
+            roles: external_prop_types_default().arrayOf(external_prop_types_default().string).isRequired
+        }).isRequired,
+        onLogout: external_prop_types_default().func.isRequired,
+        version: external_prop_types_default().string,
+        showVersion: external_prop_types_default().bool,
+        secondarySidebar: external_prop_types_default().node,
+        secondarySidebarWidth: external_prop_types_default().number,
+        storeThemeInLocalStorage: external_prop_types_default().bool
+    };
+    const ThemeToggle = ()=>{
+        const config = (0, external_react_.useContext)(CodebitConfigContext);
+        if (!config) throw new Error('ThemeToggle must be used within CodebitConfigProvider');
+        (0, external_react_.useEffect)(()=>{
+            document.documentElement.style.colorScheme = config.isDarkMode ? 'dark' : 'light';
+        }, [
+            config.isDarkMode
+        ]);
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Switch, {
+            theme: config.isDarkMode ? 'dark' : 'light',
+            checked: config.isDarkMode,
+            onChange: config.toggleTheme,
+            checkedChildren: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MoonOutlined, {}),
+            unCheckedChildren: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.SunOutlined, {})
+        });
+    };
+    const LoggedMainContainer_module = {
+        layout: "layout-mL5o6I",
+        drawer: "drawer-oj0mJX",
+        drawerBody: "drawerBody-YtAN37",
+        drawerFlex: "drawerFlex-AGTAax",
+        sider: "sider-BDy1Bs",
+        siderLayout: "siderLayout-C8H0uI",
+        secondarySidebar: "secondarySidebar-P6J_Xn",
+        menu: "menu-KMvPt7",
+        menuContainer: "menuContainer-ahnhBu",
+        menuLabel: "menuLabel-csBJTc",
+        menuDescription: "menuDescription-d6BFBO",
+        menuSpacer: "menuSpacer-RIB3II",
+        versionMenu: "versionMenu-NM4uyG",
+        logoutMenu: "logoutMenu-_RLfGo",
+        header: "header-vgc67L",
+        mobile: "mobile-mKGxb5",
+        headerSpace: "headerSpace-Fd_iha",
+        content: "content-OZHp2h"
+    };
+    const useCodebitWebAntdTranslation = ()=>(0, external_react_i18next_namespaceObject.useTranslation)('codebitWebAntd', {
+            i18n: i18n
+        });
+    const { Header, Sider, Content } = external_antd_namespaceObject.Layout;
+    const { Text } = external_antd_namespaceObject.Typography;
+    function LoggedMainContainer({ children }) {
+        const [collapsed, setCollapsed] = (0, external_react_.useState)(false);
+        const [isMobile, setIsMobile] = (0, external_react_.useState)(false);
+        const [drawerVisible, setDrawerVisible] = (0, external_react_.useState)(false);
+        const [secondarySidebarDrawerVisible, setSecondarySidebarDrawerVisible] = (0, external_react_.useState)(false);
+        const { t } = useCodebitWebAntdTranslation();
+        const navigate = (0, external_react_router_namespaceObject.useNavigate)();
+        const location = (0, external_react_router_namespaceObject.useLocation)();
+        const config = (0, external_react_.useContext)(CodebitConfigContext);
+        if (!config) throw new Error('LoggedContainer must be used within CodebitConfigProvider');
+        const { menuItems, user, onLogout, version, showVersion, isDarkMode, secondarySidebar, secondarySidebarWidth = 280 } = config;
+        const systemTheme = isDarkMode ? 'dark' : 'light';
+        const filteredMenuItems = (0, external_react_.useMemo)(()=>menuItems.filter((item)=>{
+                if (!item.roles) return true;
+                if (!user || !user.roles) return false;
+                if (item.roles) return item.roles.some((role)=>user.roles.includes(role));
+                return false;
+            }), [
+            menuItems,
+            user
+        ]);
+        (0, external_react_.useEffect)(()=>{
+            const checkScreenSize = ()=>{
+                setIsMobile(window.innerWidth < 768);
+            };
+            checkScreenSize();
+            window.addEventListener('resize', checkScreenSize);
+            return ()=>window.removeEventListener('resize', checkScreenSize);
+        }, []);
+        const handleLogout = async ()=>{
+            if (onLogout) await onLogout();
+            if (isMobile) setDrawerVisible(false);
+            navigate('/');
+        };
+        const handleMenuClick = (key)=>{
+            navigate(key);
+            if (isMobile) setDrawerVisible(false);
+        };
+        const getSelectedKey = ()=>{
+            const path = location.pathname;
+            const exactMatch = filteredMenuItems.find((item)=>item.key === path);
+            if (exactMatch) return exactMatch.key;
+            const prefixMatch = filteredMenuItems.find((item)=>path.startsWith(item.key) && '/' !== item.key);
+            if (prefixMatch) return prefixMatch.key;
+            return path;
+        };
+        const menuContent = /*#__PURE__*/ (0, jsx_runtime.jsxs)(jsx_runtime.Fragment, {
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Menu, {
+                    theme: systemTheme,
+                    mode: 'inline',
+                    selectedKeys: [
+                        getSelectedKey()
+                    ],
+                    onClick: ({ key })=>handleMenuClick(key),
+                    items: filteredMenuItems,
+                    className: LoggedMainContainer_module.menu
+                }),
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Layout.Content, {
+                    className: LoggedMainContainer_module.menuSpacer
+                }),
+                showVersion && version && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Menu, {
+                    theme: systemTheme,
+                    mode: 'horizontal',
+                    className: LoggedMainContainer_module.versionMenu,
+                    disabled: true,
+                    items: [
+                        {
+                            icon: collapsed ? `${t('LoggedMainContainer.version')}: ${version}` : version,
+                            title: ''
+                        }
+                    ]
+                }),
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Menu, {
+                    theme: systemTheme,
+                    mode: 'horizontal',
+                    onClick: handleLogout,
+                    className: LoggedMainContainer_module.logoutMenu,
+                    items: [
+                        {
+                            key: 'logout',
+                            icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.LogoutOutlined, {}),
+                            label: t('LoggedMainContainer.logout'),
+                            danger: true
+                        }
+                    ]
+                })
+            ]
+        });
+        return /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Layout, {
+            className: LoggedMainContainer_module.layout,
+            children: [
+                isMobile ? /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Drawer, {
+                    placement: 'left',
+                    onClose: ()=>setDrawerVisible(false),
+                    open: drawerVisible,
+                    width: 250,
+                    className: LoggedMainContainer_module.drawer,
+                    classNames: {
+                        body: LoggedMainContainer_module.drawerBody
+                    },
+                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
+                        vertical: true,
+                        className: LoggedMainContainer_module.drawerFlex,
+                        children: menuContent
+                    })
+                }) : /*#__PURE__*/ (0, jsx_runtime.jsx)(Sider, {
+                    theme: systemTheme,
+                    trigger: null,
+                    collapsible: true,
+                    collapsed: !collapsed,
+                    breakpoint: 'lg',
+                    collapsedWidth: 80,
+                    className: LoggedMainContainer_module.sider,
+                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Layout, {
+                        className: LoggedMainContainer_module.siderLayout,
+                        children: menuContent
+                    })
+                }),
+                secondarySidebar && !isMobile ? /*#__PURE__*/ (0, jsx_runtime.jsx)(Sider, {
+                    theme: systemTheme,
+                    width: secondarySidebarWidth,
+                    className: `${LoggedMainContainer_module.secondarySidebar} ${isDarkMode ? LoggedMainContainer_module.secondarySidebarDark : ''}`,
+                    children: secondarySidebar
+                }) : /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Drawer, {
+                    placement: 'right',
+                    onClose: ()=>setSecondarySidebarDrawerVisible(false),
+                    open: secondarySidebarDrawerVisible,
+                    width: 280,
+                    className: LoggedMainContainer_module.drawer,
+                    title: null,
+                    closeIcon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.CloseOutlined, {}),
+                    children: secondarySidebar
+                }),
+                /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Layout, {
+                    children: [
+                        /*#__PURE__*/ (0, jsx_runtime.jsxs)(Header, {
+                            className: `${LoggedMainContainer_module.header} ${isMobile ? LoggedMainContainer_module.mobile : ''}`,
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Space, {
+                                    children: isMobile ? /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                        type: 'text',
+                                        icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MenuOutlined, {}),
+                                        onClick: ()=>setDrawerVisible(true)
+                                    }) : /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                        type: 'text',
+                                        icon: collapsed ? /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MenuUnfoldOutlined, {}) : /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MenuFoldOutlined, {}),
+                                        onClick: ()=>setCollapsed(!collapsed)
+                                    })
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Space, {
+                                    size: isMobile ? 'small' : 'middle',
+                                    className: `${LoggedMainContainer_module.headerSpace} ${isMobile ? LoggedMainContainer_module.mobile : ''}`,
+                                    children: [
+                                        secondarySidebar && isMobile && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                            type: 'text',
+                                            icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MenuOutlined, {}),
+                                            onClick: ()=>setSecondarySidebarDrawerVisible(true)
+                                        }),
+                                        !isMobile && /*#__PURE__*/ (0, jsx_runtime.jsx)(Text, {
+                                            children: t('LoggedMainContainer.theme')
+                                        }),
+                                        /*#__PURE__*/ (0, jsx_runtime.jsx)(ThemeToggle, {})
+                                    ]
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ (0, jsx_runtime.jsx)(Content, {
+                            className: `${LoggedMainContainer_module.content} ${isMobile ? LoggedMainContainer_module.mobile : ''}`,
+                            children: children
+                        })
+                    ]
+                })
+            ]
+        });
+    }
+    LoggedMainContainer.propTypes = {
+        children: external_prop_types_default().node.isRequired
+    };
+    const codebit_web_namespaceObject = require("@codebit-programando-solucoes/codebit-web");
+    const react_namespaceObject = require("@sentry/react");
+    function ErrorRetry({ error, onRetry }) {
+        const { t } = useCodebitWebAntdTranslation();
+        if (error && error instanceof Error) {
+            console.error('Fail to load.', error);
+            react_namespaceObject.captureException(error);
+        }
+        const responseStatus = error?.response?.status || null;
+        let errorMessage = t('ErrorRetry.defaultError');
+        let retryText = t('ErrorRetry.retryButton');
+        let status = 'error';
+        if (error?.errorCode) switch(error.errorCode){
+            case codebit_web_namespaceObject.ErrorCode.ERR_NETWORK:
+                errorMessage = t('ErrorRetry.networkError');
+                break;
+            case codebit_web_namespaceObject.ErrorCode.ERR_TIMEOUT:
+                errorMessage = t('ErrorRetry.timeoutError');
+                break;
+        }
+        else if (responseStatus) switch(responseStatus){
+            case 400:
+                errorMessage = t('ErrorRetry.badRequestError');
+                break;
+            case 403:
+                errorMessage = t('ErrorRetry.forbiddenError');
+                retryText = t('ErrorRetry.reloadPageButton');
+                onRetry = ()=>{
+                    globalThis.location.reload();
+                };
+                status = 403;
+                break;
+            case 404:
+                errorMessage = t('ErrorRetry.notFoundError');
+                status = 404;
+                break;
+            case 500:
+                errorMessage = t('ErrorRetry.internalServerError');
+                status = 500;
+                break;
+            case 401:
+                errorMessage = t('ErrorRetry.sessionExpiredError');
+                retryText = t('ErrorRetry.reloadPageButton');
+                onRetry = ()=>{
+                    globalThis.location.reload();
+                };
+                break;
+        }
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Card, {
+            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Result, {
+                status: status,
+                title: errorMessage,
+                extra: [
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                        type: 'primary',
+                        onClick: onRetry,
+                        icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.ReloadOutlined, {}),
+                        children: retryText
+                    }, 'retry')
+                ]
+            })
+        });
+    }
+    ErrorRetry.propTypes = {
+        error: external_prop_types_default().object.isRequired,
+        onRetry: external_prop_types_default().func.isRequired
+    };
+    const ListCard_module = {
+        listCard: "listCard-ISftFd",
+        headerRow: "headerRow-UsZAzP",
+        actions: "actions-ig53s2",
+        filtersRow: "filtersRow-f3Xk5a",
+        expandArea: "expandArea-czOoFS"
+    };
+    const { Title } = external_antd_namespaceObject.Typography;
+    function ListCard({ title, onClearFilters, headerContainer, tableContainer, actions }) {
+        const { token } = external_antd_namespaceObject.theme.useToken();
+        const { t } = (0, external_react_i18next_namespaceObject.useTranslation)('codebitWebAntd');
+        const margin = token['margin'];
+        return /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Card, {
+            className: ListCard_module.listCard,
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Row, {
+                    gutter: margin,
+                    align: 'middle',
+                    className: ListCard_module.headerRow,
+                    children: [
+                        /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Col, {
+                            xs: 24,
+                            sm: 24,
+                            md: 12,
+                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(Title, {
+                                level: 4,
+                                children: title
+                            })
+                        }),
+                        (!!onClearFilters || !!actions) && /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Col, {
+                            xs: 24,
+                            sm: 24,
+                            md: 12,
+                            className: ListCard_module.actions,
+                            children: [
+                                !!onClearFilters && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                    icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.ClearOutlined, {}),
+                                    onClick: onClearFilters,
+                                    children: t('ListCard.clearFilters')
+                                }),
+                                actions
+                            ]
+                        })
+                    ]
+                }),
+                !!headerContainer && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Row, {
+                    gutter: margin,
+                    className: ListCard_module.filtersRow,
+                    children: headerContainer
+                }),
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Layout, {
+                    className: ListCard_module.expandArea,
+                    children: tableContainer
+                })
+            ]
+        });
+    }
+    ListCard.propTypes = {
+        title: external_prop_types_default().string.isRequired,
+        onClearFilters: external_prop_types_default().func,
+        headerContainer: external_prop_types_default().node,
+        tableContainer: external_prop_types_default().node,
+        actions: external_prop_types_default().node
+    };
+    ListCard.defaultProps = {
+        onClearFilters: null,
+        headerContainer: null,
+        tableContainer: null,
+        actions: null
+    };
+    const CssTokenBridge = ()=>{
+        const { token } = external_antd_namespaceObject.theme.useToken();
+        (0, external_react_.useLayoutEffect)(()=>{
+            const root = document.documentElement;
+            root.style.setProperty('--antd-color-bg-container', token['colorBgContainer']);
+            root.style.setProperty('--antd-color-bg-elevated', token['colorBgElevated']);
+            root.style.setProperty('--antd-color-bg-layout', token['colorBgLayout']);
+            root.style.setProperty('--antd-color-border', token['colorBorder']);
+            root.style.setProperty('--antd-color-primary', token['colorPrimary']);
+            root.style.setProperty('--antd-color-text', token['colorText']);
+            root.style.setProperty('--antd-color-text-secondary', token['colorTextSecondary']);
+            root.style.setProperty('--antd-color-split', token['colorSplit']);
+            root.style.setProperty('--antd-margin-xxs', `${token['marginXXS']}px`);
+            root.style.setProperty('--antd-margin-xs', `${token['marginXS']}px`);
+            root.style.setProperty('--antd-margin-sm', `${token['marginSM']}px`);
+            root.style.setProperty('--antd-margin', `${token['margin']}px`);
+            root.style.setProperty('--antd-margin-md', `${token['marginMD']}px`);
+            root.style.setProperty('--antd-margin-lg', `${token['marginLG']}px`);
+            root.style.setProperty('--antd-margin-xl', `${token['marginXL']}px`);
+            root.style.setProperty('--antd-margin-xxl', `${token['marginXXL']}px`);
+            root.style.setProperty('--antd-padding-xxs', `${token['paddingXXS']}px`);
+            root.style.setProperty('--antd-padding-xs', `${token['paddingXS']}px`);
+            root.style.setProperty('--antd-padding-sm', `${token['paddingSM']}px`);
+            root.style.setProperty('--antd-padding', `${token['padding']}px`);
+            root.style.setProperty('--antd-padding-md', `${token['paddingMD']}px`);
+            root.style.setProperty('--antd-padding-lg', `${token['paddingLG']}px`);
+            root.style.setProperty('--antd-padding-xl', `${token['paddingXL']}px`);
+            root.style.setProperty('--antd-font-size-sm', `${token['fontSizeSM']}px`);
+            root.style.setProperty('--antd-font-size', `${token['fontSize']}px`);
+            root.style.setProperty('--antd-font-size-lg', `${token['fontSizeLG']}px`);
+            root.style.setProperty('--antd-font-size-xl', `${token['fontSizeXL']}px`);
+            root.style.setProperty('--antd-line-height', token['lineHeight']);
+            root.style.setProperty('--antd-line-height-lg', token['lineHeightLG']);
+            root.style.setProperty('--antd-control-height-sm', `${token['controlHeightSM']}px`);
+            root.style.setProperty('--antd-control-height', `${token['controlHeight']}px`);
+            root.style.setProperty('--antd-control-height-lg', `${token['controlHeightLG']}px`);
+            root.style.setProperty('--antd-border-radius-sm', `${token['borderRadiusSM']}px`);
+            root.style.setProperty('--antd-border-radius', `${token['borderRadius']}px`);
+            root.style.setProperty('--antd-border-radius-lg', `${token['borderRadiusLG']}px`);
+        }, [
+            token
+        ]);
+        return null;
+    };
+    const TableContainer_module = {
+        tableContainer: "tableContainer-EhNwOm"
+    };
+    function isPaginationNode(node) {
+        if (node.nodeType !== Node.ELEMENT_NODE) return false;
+        const element = node;
+        return element.classList?.contains('ant-table-pagination') || element.querySelector?.('.ant-table-pagination');
+    }
+    function hasPaginationInMutation(mutation) {
+        return Array.from(mutation.addedNodes).some(isPaginationNode);
+    }
+    function TableContainer({ children }) {
+        const containerRef = (0, external_react_.useRef)(null);
+        const containerHeightRef = (0, external_react_.useRef)(null);
+        const [scrollY, setScrollY] = (0, external_react_.useState)(void 0);
+        (0, external_react_.useLayoutEffect)(()=>{
+            const calculateHeights = ()=>{
+                if (!containerRef.current) return;
+                containerHeightRef.current = containerRef.current.offsetHeight;
+                const thead = containerRef.current.querySelector('thead');
+                let theadHeight = 0;
+                if (thead) {
+                    const rect = thead.getBoundingClientRect();
+                    const styles = globalThis.getComputedStyle(thead);
+                    const marginTop = Number.parseFloat(styles.marginTop) || 0;
+                    const marginBottom = Number.parseFloat(styles.marginBottom) || 0;
+                    theadHeight = rect.height + marginTop + marginBottom;
+                }
+                const pagination = containerRef.current.querySelector('.ant-table-pagination');
+                let paginationHeight = 0;
+                if (pagination) {
+                    const rect = pagination.getBoundingClientRect();
+                    const styles = globalThis.getComputedStyle(pagination);
+                    const marginTop = Number.parseFloat(styles.marginTop) || 0;
+                    const marginBottom = Number.parseFloat(styles.marginBottom) || 0;
+                    paginationHeight = rect.height + marginTop + marginBottom;
+                }
+                const availableHeight = Math.ceil(containerHeightRef.current) - Math.ceil(theadHeight) - Math.ceil(paginationHeight) - 1;
+                setScrollY(availableHeight);
+            };
+            calculateHeights();
+            const observer = new MutationObserver((mutations)=>{
+                const hasPagination = mutations.some(hasPaginationInMutation);
+                if (hasPagination) calculateHeights();
+            });
+            if (containerRef.current) observer.observe(containerRef.current, {
+                childList: true,
+                subtree: true
+            });
+            globalThis.addEventListener('resize', calculateHeights);
+            return ()=>{
+                observer.disconnect();
+                globalThis.removeEventListener('resize', calculateHeights);
+            };
+        }, []);
+        const enhancedChildren = scrollY ? /*#__PURE__*/ (0, external_react_.cloneElement)(children, {
+            scroll: {
+                ...children.props?.scroll,
+                y: scrollY,
+                x: 'max-content'
+            }
+        }) : children;
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)("div", {
+            ref: containerRef,
+            className: TableContainer_module.tableContainer,
+            children: enhancedChildren
+        });
+    }
+    TableContainer.propTypes = {
+        children: external_prop_types_default().element.isRequired
+    };
+    function FilterContainer({ children, ...props }) {
+        const { token } = external_antd_namespaceObject.theme.useToken();
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Card, {
+            styles: {
+                body: {
+                    padding: token['paddingXS'] + 'px'
+                }
+            },
+            ...props,
+            children: children
+        });
+    }
+    FilterContainer.propTypes = {
+        children: external_prop_types_default().node.isRequired,
+        ...external_antd_namespaceObject.Card.propTypes
+    };
+    const Login_module = {
+        containerRow: "containerRow-lnjnDt",
+        themeRow: "themeRow-ZhL0jS",
+        loginCard: "loginCard-k07Wjb",
+        dark: "dark-JBf6Fe",
+        titleRow: "titleRow-XMkFzo",
+        appTitle: "appTitle-tL41k9",
+        divider: "divider-oJpEKR",
+        loginHeader: "loginHeader-bBGO5B"
+    };
+    function LoginContainer({ title, children }) {
+        const config = (0, external_react_.useContext)(CodebitConfigContext);
+        if (!config) throw new Error('Login must be used within CodebitConfigProvider');
+        const { t } = useCodebitWebAntdTranslation();
+        const classList = [
+            Login_module.loginCard
+        ];
+        if (config.isDarkMode) classList.push(Login_module.dark);
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Row, {
+            justify: 'center',
+            align: 'middle',
+            className: Login_module.containerRow,
+            children: /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Col, {
+                xs: 22,
+                sm: 18,
+                md: 14,
+                lg: 10,
+                xl: 8,
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Row, {
+                        justify: 'end',
+                        className: Login_module.themeRow,
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Space, {
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Text, {
+                                    children: t('LoginContainer.theme')
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(ThemeToggle, {})
+                            ]
+                        })
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Card, {
+                        className: classList.join(' '),
+                        children: [
+                            /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Row, {
+                                justify: 'center',
+                                className: Login_module.titleRow,
+                                children: [
+                                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                                        level: 3,
+                                        className: Login_module.appTitle,
+                                        children: title
+                                    }),
+                                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Divider, {
+                                        className: Login_module.divider
+                                    })
+                                ]
+                            }),
+                            children
+                        ]
+                    })
+                ]
+            })
+        });
+    }
+    LoginContainer.propTypes = {
+        title: external_prop_types_default().oneOfType([
+            external_prop_types_default().string,
+            external_prop_types_default().node
+        ]).isRequired,
+        children: external_prop_types_default().node
+    };
+    const logger = new codebit_web_namespaceObject.Logger('Login');
+    const LocalLoginAuthenticationResult = Object.freeze({
+        INVALID_EMAIL: 'INVALID_EMAIL',
+        INVALID_PASSWORD: 'INVALID_PASSWORD',
+        INVALID_EMAIL_OR_PASSWORD: 'INVALID_EMAIL_OR_PASSWORD',
+        RECAPTCHA_VALIDATION_FAIL: 'RECAPTCHA_VALIDATION_FAIL',
+        USER_DISABLED: 'USER_DISABLED',
+        SUCCESS: 'SUCCESS'
+    });
+    function Login({ title, oauthCallbackUrl, navigateToForgotPassword, submitAuthenticateLocalUser }) {
+        const [localLoading, setLocalLoading] = (0, external_react_.useState)(false);
+        const [googleLoading, setGoogleLoading] = (0, external_react_.useState)(false);
+        const [form] = external_antd_namespaceObject.Form.useForm();
+        const { t } = useCodebitWebAntdTranslation();
+        const { modal } = external_antd_namespaceObject.App.useApp();
+        const navigate = (0, external_react_router_namespaceObject.useNavigate)();
+        const context = {
+            navigate
+        };
+        const handleGoogleLogin = ()=>{
+            setGoogleLoading(true);
+            setTimeout(()=>{
+                globalThis.location.assign(oauthCallbackUrl);
+                setGoogleLoading(false);
+            }, 1000);
+        };
+        const handleLocalLogin = async (values)=>{
+            setLocalLoading(true);
+            try {
+                const { email, password } = values;
+                const result = await submitAuthenticateLocalUser(email, password, context);
+                switch(result){
+                    case LocalLoginAuthenticationResult.SUCCESS:
+                        break;
+                    case LocalLoginAuthenticationResult.INVALID_EMAIL:
+                        form.setFields([
+                            {
+                                name: 'email',
+                                errors: [
+                                    t('Common.invalidEmail')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginAuthenticationResult.INVALID_PASSWORD:
+                        form.setFields([
+                            {
+                                name: 'password',
+                                errors: [
+                                    t('Login.invalidPassword')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginAuthenticationResult.INVALID_EMAIL_OR_PASSWORD:
+                        form.setFields([
+                            {
+                                name: 'email',
+                                errors: [
+                                    t('Login.invalidEmailOrPassword')
+                                ]
+                            },
+                            {
+                                name: 'password',
+                                errors: [
+                                    t('Login.invalidEmailOrPassword')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginAuthenticationResult.RECAPTCHA_VALIDATION_FAIL:
+                        modal.error({
+                            title: t('Login.authenticationFailed'),
+                            content: t('Common.recaptchaFailed'),
+                            okText: t('Common.ok')
+                        });
+                        break;
+                    case LocalLoginAuthenticationResult.USER_DISABLED:
+                        modal.error({
+                            title: t('Login.authenticationFailed'),
+                            content: t('Login.userDisabled'),
+                            okText: t('Common.ok')
+                        });
+                        break;
+                    default:
+                        logger.warn('Unhandled authentication result:', result);
+                        modal.error({
+                            title: t('Login.authenticationFailed'),
+                            content: t('Common.genericError'),
+                            okText: t('Common.ok')
+                        });
+                }
+            } catch (error) {
+                logger.error(error);
+                react_namespaceObject.captureException(error);
+                modal.error({
+                    title: t('Login.errorTitle'),
+                    content: t('Common.genericError'),
+                    okText: t('Common.ok')
+                });
+            } finally{
+                setLocalLoading(false);
+            }
+        };
+        const handleNavigateToForgotPassword = async ()=>{
+            await navigateToForgotPassword(context);
+        };
+        return /*#__PURE__*/ (0, jsx_runtime.jsxs)(LoginContainer, {
+            title: title || t('Login.loginTitle'),
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                    level: 4,
+                    className: `${Login_module.loginHeader}`,
+                    children: t('LoginContainer.signIn')
+                }),
+                /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Space, {
+                    direction: 'vertical',
+                    size: 'large',
+                    style: {
+                        width: '100%'
+                    },
+                    children: [
+                        submitAuthenticateLocalUser && /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Form, {
+                            name: 'login-form',
+                            layout: 'vertical',
+                            onFinish: handleLocalLogin,
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    name: 'email',
+                                    label: t('Login.emailLabel'),
+                                    rules: [
+                                        {
+                                            required: true,
+                                            message: t('Login.emailRequired')
+                                        },
+                                        {
+                                            type: 'email',
+                                            message: t('Login.emailInvalid')
+                                        }
+                                    ],
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Input, {
+                                        prefix: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MailOutlined, {}),
+                                        placeholder: t('Login.emailPlaceholder'),
+                                        size: 'large'
+                                    })
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    name: 'password',
+                                    label: t('Login.passwordLabel'),
+                                    rules: [
+                                        {
+                                            required: true,
+                                            message: t('Login.passwordRequired')
+                                        }
+                                    ],
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Input.Password, {
+                                        prefix: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.LockOutlined, {}),
+                                        placeholder: t('Login.passwordPlaceholder'),
+                                        size: 'large'
+                                    })
+                                }),
+                                navigateToForgotPassword && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Row, {
+                                        justify: 'end',
+                                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Col, {
+                                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Link, {
+                                                onClick: handleNavigateToForgotPassword,
+                                                children: t('Login.forgotPassword')
+                                            })
+                                        })
+                                    })
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    style: {
+                                        marginBottom: 0
+                                    },
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                        type: 'primary',
+                                        htmlType: 'submit',
+                                        size: 'large',
+                                        loading: localLoading,
+                                        disabled: googleLoading,
+                                        block: true,
+                                        children: t('Login.loginButton')
+                                    })
+                                })
+                            ]
+                        }),
+                        submitAuthenticateLocalUser && oauthCallbackUrl && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Divider, {
+                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Text, {
+                                type: 'secondary',
+                                children: t('Login.separator')
+                            })
+                        }),
+                        oauthCallbackUrl && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
+                            vertical: true,
+                            align: 'center',
+                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                type: 'primary',
+                                size: 'large',
+                                icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.GoogleOutlined, {}),
+                                loading: googleLoading,
+                                onClick: handleGoogleLogin,
+                                disabled: localLoading,
+                                block: true,
+                                children: t('Login.googleLogin')
+                            })
+                        })
+                    ]
+                })
+            ]
+        });
+    }
+    Login.propTypes = {
+        title: external_prop_types_default().oneOfType([
+            external_prop_types_default().string,
+            external_prop_types_default().node
+        ]),
+        oauthCallbackUrl: external_prop_types_default().string,
+        navigateToForgotPassword: external_prop_types_default().func,
+        submitAuthenticateLocalUser: external_prop_types_default().func
+    };
+    const HandleError_module = {
+        container: "container-A_JXAc",
+        content: "content-yh3y0U",
+        title: "title-rFxsxp",
+        errorDetails: "errorDetails-DjtTbH",
+        errorStack: "errorStack-DJzbWD"
+    };
+    function HandleError({ title }) {
+        const error = (0, external_react_router_namespaceObject.useRouteError)();
+        const navigate = (0, external_react_router_namespaceObject.useNavigate)();
+        const { t } = useCodebitWebAntdTranslation();
+        const handleGoHome = ()=>{
+            navigate('/');
+        };
+        const getErrorStatus = ()=>{
+            if (error && 404 === error.status) return 404;
+            if (error && 403 === error.status) return 403;
+            if (error && 500 === error.status) return 500;
+            return 'error';
+        };
+        const getErrorMessage = ()=>{
+            if (error && 404 === error.status) return t('HandleError.notFoundMessage');
+            if (error && 403 === error.status) return t('HandleError.forbiddenMessage');
+            if (error && 500 === error.status) return t('HandleError.internalMessage');
+            return error && error.message || t('HandleError.genericMessage');
+        };
+        const getErrorTitle = ()=>{
+            if (error && 404 === error.status) return t('HandleError.notFoundTitle');
+            if (error && 403 === error.status) return t('HandleError.forbiddenTitle');
+            if (error && 500 === error.status) return t('HandleError.internalTitle');
+            return t('HandleError.genericTitle');
+        };
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
+            justify: 'center',
+            align: 'center',
+            className: HandleError_module.container,
+            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
+                className: HandleError_module.content,
+                children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Result, {
+                    status: getErrorStatus(),
+                    title: /*#__PURE__*/ (0, jsx_runtime.jsxs)(jsx_runtime.Fragment, {
+                        children: [
+                            /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                                level: 2,
+                                className: HandleError_module.title,
+                                children: title
+                            }),
+                            getErrorTitle()
+                        ]
+                    }),
+                    subTitle: getErrorMessage(),
+                    extra: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                        type: 'primary',
+                        size: 'large',
+                        onClick: handleGoHome,
+                        children: t('HandleError.backHome')
+                    })
+                })
+            })
+        });
+    }
+    HandleError.propTypes = {
+        title: external_prop_types_default().string
+    };
+    const ForgotPassword_logger = new codebit_web_namespaceObject.Logger('ForgotPassword');
+    const LocalLoginRecoveryPasswordResult = Object.freeze({
+        INVALID_EMAIL: 'INVALID_EMAIL',
+        RECAPTCHA_VALIDATION_FAIL: 'RECAPTCHA_VALIDATION_FAIL',
+        SUCCESS: 'SUCCESS'
+    });
+    const ForgotPassword = ({ navigateToLogin, submitRecoveryPassword })=>{
+        const [form] = external_antd_namespaceObject.Form.useForm();
+        const { modal } = external_antd_namespaceObject.App.useApp();
+        const [loading, setLoading] = (0, external_react_.useState)(false);
+        const { t } = useCodebitWebAntdTranslation();
+        const navigate = (0, external_react_router_namespaceObject.useNavigate)();
+        const context = {
+            navigate
+        };
+        const handleNavigateToLogin = async ()=>{
+            await navigateToLogin(context);
+        };
+        const handleRecoveryPassword = async (values)=>{
+            setLoading(true);
+            try {
+                setLoading(true);
+                const result = await submitRecoveryPassword(values.email, context);
+                switch(result){
+                    case LocalLoginRecoveryPasswordResult.SUCCESS:
+                        modal.success({
+                            title: t('ForgotPassword.title'),
+                            content: t('ForgotPassword.resetSuccessMessage'),
+                            onOk: handleNavigateToLogin,
+                            okText: t('Common.ok')
+                        });
+                        break;
+                    case LocalLoginRecoveryPasswordResult.INVALID_EMAIL:
+                        form.setFields([
+                            {
+                                name: 'email',
+                                errors: [
+                                    t('Common.invalidEmail')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginRecoveryPasswordResult.RECAPTCHA_VALIDATION_FAIL:
+                        modal.error({
+                            title: t('ForgotPassword.title'),
+                            content: t('Common.recaptchaFailed'),
+                            okText: t('Common.ok')
+                        });
+                        break;
+                }
+            } catch (error) {
+                ForgotPassword_logger.error(error);
+                react_namespaceObject.captureException(error);
+                modal.error({
+                    title: t('ForgotPassword.title'),
+                    content: t('Common.genericError'),
+                    okText: t('Common.ok')
+                });
+            } finally{
+                setLoading(false);
+            }
+        };
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(LoginContainer, {
+            title: t('ForgotPassword.title'),
+            children: /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Form, {
+                form: form,
+                name: 'forgot-password-form',
+                onFinish: handleRecoveryPassword,
+                initialValues: {
+                    email: ''
+                },
+                style: {
+                    width: '100%'
+                },
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Paragraph, {
+                        style: {
+                            textAlign: 'center'
+                        },
+                        children: t('ForgotPassword.instructions')
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                        name: 'email',
+                        rules: [
+                            {
+                                required: true,
+                                message: t('ForgotPassword.emailRequired')
+                            },
+                            {
+                                type: 'email',
+                                message: t('ForgotPassword.emailInvalid')
+                            }
+                        ],
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Input, {
+                            prefix: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MailOutlined, {}),
+                            placeholder: t('ForgotPassword.emailPlaceholder'),
+                            size: 'large'
+                        })
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                            type: 'primary',
+                            htmlType: 'submit',
+                            size: 'large',
+                            loading: loading,
+                            style: {
+                                width: '100%'
+                            },
+                            children: t('ForgotPassword.submitButton')
+                        })
+                    }),
+                    navigateToLogin && /*#__PURE__*/ (0, jsx_runtime.jsx)("div", {
+                        style: {
+                            textAlign: 'center'
+                        },
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Link, {
+                            onClick: handleNavigateToLogin,
+                            children: t('ForgotPassword.backToLogin')
+                        })
+                    })
+                ]
+            })
+        });
+    };
+    ForgotPassword.propTypes = {
+        navigateToLogin: external_prop_types_default().func,
+        submitRecoveryPassword: external_prop_types_default().func.isRequired
+    };
+    const CodebitTheme = (props)=>{
+        const { token } = external_antd_namespaceObject.theme.useToken();
+        const config = (0, external_react_.useContext)(CodebitConfigContext);
+        if (!config) throw new Error('CodebitTheme must be used within CodebitConfigProvider');
+        const { isDarkMode } = config;
+        (0, external_react_.useEffect)(()=>{
+            const rootElement = document.getElementById('root');
+            if (isDarkMode) {
+                document.body.classList.add('dark-theme');
+                rootElement.classList.add('dark-theme');
+            } else {
+                document.body.classList.remove('dark-theme');
+                rootElement.classList.remove('dark-theme');
+            }
+            document.documentElement.style.setProperty('--color-primary', isDarkMode ? '#589C75' : '#29D266');
+        }, [
+            isDarkMode,
+            token.colorBgContainer
+        ]);
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.ConfigProvider, {
+            theme: {
+                algorithm: isDarkMode ? external_antd_namespaceObject.theme.darkAlgorithm : external_antd_namespaceObject.theme.defaultAlgorithm,
+                token: {
+                    colorPrimary: isDarkMode ? '#589C75' : '#29D266',
+                    colorInfo: isDarkMode ? '#589C75' : '#29D266',
+                    colorLink: isDarkMode ? '#589C75' : '#29D266'
+                },
+                components: {
+                    Menu: {
+                        itemSelectedBg: isDarkMode ? '#589C75' : '#29D266',
+                        itemSelectedColor: '#FAFAFA',
+                        darkItemSelectedBg: isDarkMode ? '#589C75' : '#29D266',
+                        darkItemSelectedColor: '#FAFAFA'
+                    },
+                    Button: {
+                        colorPrimary: isDarkMode ? '#589C75' : '#29D266',
+                        colorPrimaryHover: isDarkMode ? '#6DB589' : '#3FE67F',
+                        colorPrimaryActive: isDarkMode ? '#4A8361' : '#1FBF4D'
+                    },
+                    Layout: {
+                        siderBg: isDarkMode ? '#1a1a1a' : '#001529',
+                        triggerBg: isDarkMode ? '#589C75' : '#29D266',
+                        triggerColor: '#FAFAFA'
+                    },
+                    Header: {
+                        colorPrimary: isDarkMode ? '#589C75' : '#29D266'
+                    }
+                }
+            },
+            ...props
+        });
+    };
+    CodebitTheme.propTypes = {};
+})();
+exports.CodebitConfigContext = __webpack_exports__.CodebitConfigContext;
+exports.CodebitConfigProvider = __webpack_exports__.CodebitConfigProvider;
+exports.CodebitTheme = __webpack_exports__.CodebitTheme;
+exports.CssTokenBridge = __webpack_exports__.CssTokenBridge;
+exports.ErrorRetry = __webpack_exports__.ErrorRetry;
+exports.FilterContainer = __webpack_exports__.FilterContainer;
+exports.ForgotPassword = __webpack_exports__.ForgotPassword;
+exports.HandleError = __webpack_exports__.HandleError;
+exports.ListCard = __webpack_exports__.ListCard;
+exports.LocalLoginAuthenticationResult = __webpack_exports__.LocalLoginAuthenticationResult;
+exports.LocalLoginRecoveryPasswordResult = __webpack_exports__.LocalLoginRecoveryPasswordResult;
+exports.LoggedMainContainer = __webpack_exports__.LoggedMainContainer;
+exports.Login = __webpack_exports__.Login;
+exports.LoginContainer = __webpack_exports__.LoginContainer;
+exports.TableContainer = __webpack_exports__.TableContainer;
+exports.ThemeToggle = __webpack_exports__.ThemeToggle;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "CodebitConfigContext",
+    "CodebitConfigProvider",
+    "CodebitTheme",
+    "CssTokenBridge",
+    "ErrorRetry",
+    "FilterContainer",
+    "ForgotPassword",
+    "HandleError",
+    "ListCard",
+    "LocalLoginAuthenticationResult",
+    "LocalLoginRecoveryPasswordResult",
+    "LoggedMainContainer",
+    "Login",
+    "LoginContainer",
+    "TableContainer",
+    "ThemeToggle"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});