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

package/dist/index.cjs

@@ -0,0 +1,1184 @@
+/*! 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,
+        FilterContainer: ()=>FilterContainer,
+        HandleError: ()=>HandleError,
+        ErrorRetry: ()=>ErrorRetry,
+        CodebitConfigProvider: ()=>CodebitConfigProvider,
+        CodebitConfigContext: ()=>CodebitConfigContext,
+        ListCard: ()=>ListCard,
+        ThemeToggle: ()=>ThemeToggle,
+        LoginContainer: ()=>LoginContainer
+    });
+    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'
+            },
+            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'
+            }
+        }
+    };
+    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'
+            },
+            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'
+            }
+        }
+    };
+    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, toggleTheme, isDarkMode, oauthCallbackUrl, version = '1.0', showVersion = true, secondarySidebar, secondarySidebarWidth = 280 }) {
+        const contextValue = (0, external_react_.useMemo)(()=>({
+                menuItems,
+                user,
+                onLogout,
+                toggleTheme,
+                isDarkMode,
+                oauthCallbackUrl,
+                version,
+                showVersion,
+                i18n: i18n,
+                secondarySidebar,
+                secondarySidebarWidth
+            }), [
+            menuItems,
+            user,
+            onLogout,
+            toggleTheme,
+            isDarkMode,
+            version,
+            showVersion,
+            oauthCallbackUrl,
+            secondarySidebar,
+            secondarySidebarWidth
+        ]);
+        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,
+        toggleTheme: external_prop_types_default().func.isRequired,
+        isDarkMode: external_prop_types_default().bool.isRequired,
+        oauthCallbackUrl: external_prop_types_default().string.isRequired,
+        secondarySidebar: external_prop_types_default().node,
+        secondarySidebarWidth: external_prop_types_default().number
+    };
+    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: [
+                                    'string' == typeof title ? /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                                        level: 3,
+                                        className: Login_module.appTitle,
+                                        children: title
+                                    }) : title,
+                                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Divider, {
+                                        className: Login_module.divider
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                                level: 4,
+                                className: `login-header ${Login_module.loginHeader}`,
+                                children: t('LoginContainer.signIn')
+                            }),
+                            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
+    };
+    function Login({ title }) {
+        const [loading, setLoading] = (0, external_react_.useState)(false);
+        const config = (0, external_react_.useContext)(CodebitConfigContext);
+        if (!config) throw new Error('Login must be used within CodebitConfigProvider');
+        const { oauthCallbackUrl } = config;
+        const { t } = useCodebitWebAntdTranslation();
+        const handleGoogleLogin = ()=>{
+            setLoading(true);
+            setTimeout(()=>{
+                console.debug('Redirecting to Google Login...');
+                globalThis.location.assign(oauthCallbackUrl);
+            }, 1000);
+        };
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(LoginContainer, {
+            title: title || t('Login.loginTitle'),
+            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
+                vertical: true,
+                align: 'center',
+                gap: 20,
+                children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                    type: 'primary',
+                    size: 'large',
+                    icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.GoogleOutlined, {}),
+                    loading: loading,
+                    onClick: handleGoogleLogin,
+                    block: true,
+                    children: t('Login.googleLogin')
+                })
+            })
+        });
+    }
+    Login.propTypes = {
+        title: external_prop_types_default().oneOfType([
+            external_prop_types_default().string,
+            external_prop_types_default().node
+        ])
+    };
+    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
+    };
+})();
+exports.CodebitConfigContext = __webpack_exports__.CodebitConfigContext;
+exports.CodebitConfigProvider = __webpack_exports__.CodebitConfigProvider;
+exports.CssTokenBridge = __webpack_exports__.CssTokenBridge;
+exports.ErrorRetry = __webpack_exports__.ErrorRetry;
+exports.FilterContainer = __webpack_exports__.FilterContainer;
+exports.HandleError = __webpack_exports__.HandleError;
+exports.ListCard = __webpack_exports__.ListCard;
+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",
+    "CssTokenBridge",
+    "ErrorRetry",
+    "FilterContainer",
+    "HandleError",
+    "ListCard",
+    "LoggedMainContainer",
+    "Login",
+    "LoginContainer",
+    "TableContainer",
+    "ThemeToggle"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});