// components
import { Navigate, Outlet } from 'react-router-dom';

import useFeatureFlag from 'src/hooks/useFeatureFlag';
import { FeatureFlags } from 'src/types/featureFlags';
import { FormTypes } from 'src/types/form';
import {
  ROUTE_GRANTS,
  ROUTE_PERMISSIONS,
  UserPermissions,
} from 'src/utils/permissions';

import UsersGuard from './components/guards/UsersGuard';
import GrupoEfeGuard from './components/RolesGuard';
import { Loadable, lazyRetry } from './lazyLoad';
import { agentsRouterConfig } from './pages/dashboard/Agents/router';
import {
  pxPaths,
  pxRouteConfig,
  pxRoutes,
} from './pages/dashboard/PeopleExperience/routes';
import { prodePaths } from './pages/dashboard/Prode/routes';
import { NonUserBulkUploadTypes, UsersBulkUploadTypes } from './types/bulk';
import { Module } from './types/modules';
import { insertIf } from './utils/arrayUtils';
import { Roles } from './utils/hardcodedPermissionsByRole';

const AuthGuard = Loadable(lazyRetry(() => import('./components/AuthGuard')));
const DashboardLayout = Loadable(
  lazyRetry(() => import('./components/DashboardLayout')),
);
const GuestGuard = Loadable(lazyRetry(() => import('./components/GuestGuard')));
const PermissionsGuard = Loadable(
  lazyRetry(() => import('./components/PermissionsGuard')),
);

const BulkDelete = Loadable(lazyRetry(() => import('./components/BulkDelete')));
const CriteriaProvider = Loadable(
  lazyRetry(() => import('./components/Audience/criteriaContext')),
);

// Authentication pages

const Login = Loadable(lazyRetry(() => import('./pages/authentication/Login')));
const LoginOTP = Loadable(
  lazyRetry(() => import('./pages/authentication/LoginOTP')),
);

// Dashboard pages

const Forms = Loadable(
  lazyRetry(() => import('./pages/dashboard/Forms/Forms')),
);
const Form = Loadable(lazyRetry(() => import('./pages/dashboard/Forms/Form')));
const Settings = Loadable(
  lazyRetry(() => import('./pages/dashboard/Settings/General')),
);
const SecuritySettings = Loadable(
  lazyRetry(() => import('./pages/dashboard/Settings/Security')),
);

// Departments
const NewDepartment = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Settings/General/components/DepartmentsSettings/NewDepartment'
      ),
  ),
);

const EditDepartment = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Settings/General/components/DepartmentsSettings/EditDepartment'
      ),
  ),
);

// Positions
const NewPosition = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Settings/General/components/PositionsSettings/NewPosition'
      ),
  ),
);

const EditPosition = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Settings/General/components/PositionsSettings/EditPosition'
      ),
  ),
);

const News = Loadable(lazyRetry(() => import('./pages/dashboard/News/List')));
const EditNews = Loadable(
  lazyRetry(() => import('./pages/dashboard/News/Edit')),
);
const Widgets = Loadable(
  lazyRetry(() => import('./pages/dashboard/Widgets/Widgets')),
);
const Widget = Loadable(
  lazyRetry(() => import('./pages/dashboard/Widgets/Widget')),
);

// Libraries
const LibrariesRoutes = Loadable(
  lazyRetry(() => import('./pages/dashboard/HuLibraries/HuLibrariesRoutes')),
);

const LegacyLibrariesRoutes = Loadable(
  lazyRetry(() => import('./pages/dashboard/Libraries/LegacyLibrariesRoutes')),
);

// TODO-[Dolphin]:Temporarily, remove this once the migration is complete.
const LibrariesEntry = () => {
  const isNewLibrariesRouteEnabled = useFeatureFlag(
    FeatureFlags.VIEW_KNOWLEDGE_LIBRARIES_V2,
  );
  return isNewLibrariesRouteEnabled ? (
    <LibrariesRoutes />
  ) : (
    <LegacyLibrariesRoutes />
  );
};

const BulkUpload = Loadable(lazyRetry(() => import('./components/BulkUpload')));
const HuBulkUpload = Loadable(
  lazyRetry(() => import('./components/BulkUpload/hugo')),
);
const BulkUploadChats = Loadable(
  lazyRetry(() => import('./components/BulkUploadChats')),
);
const Users = Loadable(lazyRetry(() => import('./pages/dashboard/Users/List')));
const User = Loadable(lazyRetry(() => import('./pages/dashboard/Users/User')));
const UserEdit = Loadable(
  lazyRetry(() => import('./pages/dashboard/Users/UserEdit')),
);
const Groups = Loadable(
  lazyRetry(() => import('./pages/dashboard/Groups/List')),
);
const MultiCompanyGroupInvitation = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Groups/MultiCompanyGroupInvitation'),
  ),
);
const NewGroup = Loadable(
  lazyRetry(() => import('./pages/dashboard/Groups/NewGroup')),
);
const EditGroup = Loadable(
  lazyRetry(() => import('./pages/dashboard/Groups/Edit')),
);
const GroupsCompanyInvitations = Loadable(
  lazyRetry(() => import('./pages/dashboard/Groups/Requests')),
);
const Segmentation = Loadable(
  lazyRetry(() => import('./pages/dashboard/Segmentation/List')),
);
const Insights = Loadable(
  lazyRetry(() => import('./pages/dashboard/Insights')),
);
const Referral = Loadable(
  lazyRetry(() => import('./pages/dashboard/Referral')),
);
const Files = Loadable(lazyRetry(() => import('./pages/dashboard/Files/List')));
const Documents = Loadable(
  lazyRetry(() => import('./pages/dashboard/Documents')),
);
const DocumentsEdit = Loadable(
  lazyRetry(() => import('./pages/dashboard/Documents/Edit')),
);
const EditFileContainer = Loadable(
  lazyRetry(() => import('./pages/dashboard/Files/File/Edit')),
);
const NewFileContainer = Loadable(
  lazyRetry(() => import('./pages/dashboard/Files/File/New')),
);
const BulkUploadFiles = Loadable(
  lazyRetry(() => import('./components/BulkUploadFiles')),
);
const Acknowledgements = Loadable(
  lazyRetry(() => import('./pages/dashboard/Acknowledgements')),
);
const AcknowledgementProduct = Loadable(
  lazyRetry(() => import('./pages/dashboard/Acknowledgements/Product')),
);
const AcknowledgementCategoryForm = Loadable(
  lazyRetry(() => import('./pages/dashboard/Acknowledgements/Categories/New')),
);
const Vacations = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations')),
);
const PolicyTypeEdit = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations/PolicyTypeEdit')),
);
const PolicyEdit = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations/PolicyEdit')),
);
const Approvers = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations/Approvers')),
);
const AssignPeople = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations/AssignPeople')),
);
const VacationsConflicts = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations/Conflicts')),
);
const OrderPolicies = Loadable(
  lazyRetry(() => import('./pages/dashboard/Vacations/OrderPolicies')),
);
const Onboardings = Loadable(
  lazyRetry(() => import('./pages/dashboard/Onboardings/Onboardings')),
);
const EmployeeLifecycle = Loadable(
  lazyRetry(() => import('./pages/dashboard/EmployeeLifecycle/List')),
);
const EmployeeLifecycleNewProcess = Loadable(
  lazyRetry(() => import('./pages/dashboard/EmployeeLifecycle/Process/New')),
);
const EmployeeLifecycleEditProcess = Loadable(
  lazyRetry(() => import('./pages/dashboard/EmployeeLifecycle/Process/Edit')),
);
const EmployeeLifecycleProcessReport = Loadable(
  lazyRetry(() => import('./pages/dashboard/EmployeeLifecycle/Process/Report')),
);

const OnboardingsTask = Loadable(
  lazyRetry(() => import('./pages/dashboard/Onboardings/Task')),
);
const OnboardingsQuiz = Loadable(
  lazyRetry(() => import('./pages/dashboard/Onboardings/Quiz')),
);
const Apps = Loadable(lazyRetry(() => import('./pages/dashboard/Apps')));
const Questions = Loadable(
  lazyRetry(() => import('./pages/dashboard/Performance/Questions')),
);
const Templates = Loadable(
  lazyRetry(() => import('./pages/dashboard/Performance/Templates')),
);
const Template = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Performance/Templates/components/Template'),
  ),
);
const Cycles = Loadable(
  lazyRetry(() => import('./pages/dashboard/Performance/Cycles')),
);
const CycleEdit = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Performance/Cycles/components/CycleEdit'),
  ),
);
const Cycle = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Performance/Cycles/components/Cycle'),
  ),
);
const CalibrationRuleCreate = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Performance/Cycles/components/CalibrationRuleCreate'
      ),
  ),
);

/** Competencies */
const Competencies = Loadable(
  lazyRetry(() => import('./pages/dashboard/Competencies')),
);

const ManageCompetencyProfile = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Competencies/ManageCompetencyProfile'),
  ),
);

/** Temporally hidden page */
/* const CycleResults = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Performance/Cycles/components/CycleResults'),
  ),
); */

const GoalCycles = Loadable(
  lazyRetry(() => import('./pages/dashboard/Goals/Cycles')),
);

const BulkUploadGoals = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Goals/Cycles/components/BulkUploadGoals'),
  ),
);

const GoalDetail = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Goals/Cycles/components/Cycle/GoalDetail'),
  ),
);

const EditGoal = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Goals/Cycles/components/Cycle/EditGoal'),
  ),
);

const GoalEdit = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Goals/Cycles/components/CycleEdit'),
  ),
);
const GoalCycle = Loadable(
  lazyRetry(() => import('./pages/dashboard/Goals/Cycles/components/Cycle')),
);
const GoalConfiguration = Loadable(
  lazyRetry(() => import('./pages/dashboard/Goals/Configuration')),
);

// Regions & Sites
const Regions = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/List')),
);
const RegionCreate = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/RegionCreate')),
);
const RegionEdit = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/RegionEdit')),
);
const RegionGeneral = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/RegionEdit/RegionGeneral')),
);
const RegionHolidays = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Regions/RegionEdit/RegionHolidays'),
  ),
);
const RegionCollaborators = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Regions/RegionEdit/RegionCollaborators'),
  ),
);
const Sites = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/Sites/List')),
);
const SiteCreate = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/Sites/SiteCreate')),
);
const SiteEdit = Loadable(
  lazyRetry(() => import('./pages/dashboard/Regions/Sites/SiteEdit/index')),
);
const SiteGeneral = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Regions/Sites/SiteEdit/SiteGeneral'),
  ),
);
const SiteLocation = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Regions/Sites/SiteEdit/SiteLocation'),
  ),
);
const SiteCollaborators = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Regions/Sites/SiteEdit/SiteCollaborators'),
  ),
);

// PRODE Admin
const ProdeList = Loadable(
  lazyRetry(() => import('./pages/dashboard/Prode/List')),
);
const ProdeCreate = Loadable(
  lazyRetry(() => import('./pages/dashboard/Prode/Create')),
);
const ProdeDetail = Loadable(
  lazyRetry(() => import('./pages/dashboard/Prode/Detail')),
);
const ProdeParticipantsTab = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Prode/Detail/components/ParticipantsTab'),
  ),
);
const ProdePrizesTab = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Prode/Detail/components/PrizesTab'),
  ),
);

// Learning -> Courses
const Courses = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Courses/List')),
);
const CourseNew = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Courses/New')),
);
const CourseReport = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Courses/Report')),
);

// Learning -> Paths
const Paths = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Paths/List')),
);

const PathNew = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Paths/New')),
);

// Learning -> Sessions
const Sessions = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Sessions/List')),
);
const SessionNew = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Sessions/New')),
);

const ManageSessionAttendance = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Learning/Sessions/ManageAttendance'),
  ),
);

// Learning -> Settings
const LearningSettings = Loadable(
  lazyRetry(() => import('./pages/dashboard/Learning/Settings/Home')),
);
const LearningSettingsCategories = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/Learning/Settings/Categories/List'),
  ),
);
const CertificatesEntry = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Learning/Settings/Certificates/routes/CertificatesEntry'
      ),
  ),
);
// Service Management

const PdfCreation = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/ServiceManagement/NewServiceItem/components/FormCreation/pdf/PdfCreation'
      ),
  ),
);

const ServiceItems = Loadable(
  lazyRetry(
    () =>
      import('./pages/dashboard/ServiceManagement/ServiceItems/ServiceItems'),
  ),
);
const NewServiceItem = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/ServiceManagement/NewServiceItem/NewServiceItem'
      ),
  ),
);

const Agents = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/ServiceManagement/AgentManagement/Agents'),
  ),
);

const AgentProfile = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/ServiceManagement/AgentManagement/AgentProfile'
      ),
  ),
);

const CreateOrEditAgentGroup = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/ServiceManagement/AgentManagement/CreateOrEditAgentGroup'
      ),
  ),
);

const ServiceManagementMetrics = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/ServiceManagement/Metrics/Metrics'),
  ),
);

const AgentManagement = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/ServiceManagement/AgentManagement/AgentManagement'
      ),
  ),
);

const HelpDesks = Loadable(
  lazyRetry(
    () =>
      import('./pages/dashboard/ServiceManagement/AgentManagement/HelpDesks'),
  ),
);

// Work schedules
const WorkSchedules = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/WorkSchedules')),
);
const CreateSchedule = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/TimeTracking/WorkSchedules/CreateSchedule'),
  ),
);
const EditWorkSchedule = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/TimeTracking/WorkSchedules/EditSchedule'),
  ),
);
const ScheduleAssignments = Loadable(
  lazyRetry(
    () => import('./pages/dashboard/TimeTracking/WorkSchedules/Assignments'),
  ),
);
const EditWorkScheduleCollaborators = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/WorkSchedules/Assignments/AssignCollaborators'
      ),
  ),
);
const CollabsList = Loadable(
  lazyRetry(
    () =>
      import('./pages/dashboard/TimeTracking/WorkSchedules/List/CollabsList'),
  ),
);
const SchedulesList = Loadable(
  lazyRetry(
    () =>
      import('./pages/dashboard/TimeTracking/WorkSchedules/List/SchedulesList'),
  ),
);
// Time tracking
const TimePoliciesBase = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Policies')),
);
const TimePoliciesList = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Policies/List')),
);
const TimePoliciesApprovers = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Policies/Approvers')),
);

const CreateTimePolicy = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Policies/New')),
);
const EditTimePolicy = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Policies/Edit')),
);
const TimePolicyGeneralData = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/GeneralStep'
      ),
  ),
);
const TimePolicyMarkingMethods = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/MarkingMethods'
      ),
  ),
);
const TimePolicyRestrictions = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/Restrictions'
      ),
  ),
);
const TimePolicyAutomations = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/Automations'
      ),
  ),
);
const TimePolicyAssignments = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/Assignments'
      ),
  ),
);
const TimePolicyHoursManagement = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/HoursManagement'
      ),
  ),
);
const TimePolicyApprovers = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Policies/New/components/Approvers'
      ),
  ),
);
const Kiosk = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Kiosk')),
);
const CreateKioskTerminal = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Kiosk/New')),
);
const LinkKioskTerminal = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Kiosk/Link')),
);
const EditKioskTerminal = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Kiosk/Edit')),
);
const TimeTrackingSettings = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Settings')),
);
const CreateCategorizedHours = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Settings/new')),
);
const EditCategorizedHours = Loadable(
  lazyRetry(() => import('./pages/dashboard/TimeTracking/Settings/Edit')),
);
const CategorizedHoursGeneralData = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Settings/Edit/components/GeneralData'
      ),
  ),
);
const CategorizedHoursRulesTab = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/TimeTracking/Settings/Edit/components/RulesTab'
      ),
  ),
);

// Workflows
const WorkflowWithProvider = Loadable(
  lazyRetry(() => import('./pages/dashboard/Workflows/WorkflowWithProvider')),
);

const Workflows = Loadable(
  lazyRetry(() => import('./pages/dashboard/Workflows/Workflows')),
);

// Reports (for now is exclusive to 'grupoEFE')
const Reports = Loadable(lazyRetry(() => import('./pages/dashboard/Reports/')));

// Communication
const DraftsForReview = Loadable(
  lazyRetry(() => import('./pages/dashboard/Communication/DraftsForReview')),
);
const CreateDraftPermission = Loadable(
  lazyRetry(
    () =>
      import(
        './pages/dashboard/Communication/DraftsForReview/CreateDraftPermission'
      ),
  ),
);

// Roles and Permissions
const RolesAndPermissions = Loadable(
  lazyRetry(() => import('./pages/dashboard/RolesAndPermissions')),
);

const RoleForm = Loadable(
  lazyRetry(() => import('./pages/dashboard/RolesAndPermissions/RoleForm')),
);

// Applicant Tracking System (Recruiting)
const Recruiting = Loadable(
  lazyRetry(() => import('./pages/dashboard/Recruiting')),
);

// Tali (Retention / Asistencia Inteligente)
const RetentionConversationList = Loadable(
  lazyRetry(() => import('./pages/dashboard/Tali/RetentionConversationList')),
);
const RetentionConversationDetail = Loadable(
  lazyRetry(() => import('./pages/dashboard/Tali/RetentionConversationDetail')),
);

export type PartialRoute = {
  path?: string;
  element?: JSX.Element;
  index?: boolean;
  requireAllPermissions?: boolean; // In case all the permissions are needed for the defaultPath
  children?: PartialRoute[];
  defaultPathIfModule?: Module;
};

const getRoutes = (
  canViewCustomReports: boolean,
  availableModules: Module[] | null,
) => {
  const dashboardPartialRoute: PartialRoute = {
    path: '',
    element: (
      <AuthGuard>
        <DashboardLayout />
      </AuthGuard>
    ),
    children: [
      {
        path: 'insights',
        defaultPathIfModule: Module.INSIGHTS,
        element: (
          <PermissionsGuard
            requiredPermissions={ROUTE_PERMISSIONS.ANALYTICS}
            cerberusRequiredPermissions={ROUTE_PERMISSIONS.CERBERUS.INSIGHTS}
          >
            <Insights />
          </PermissionsGuard>
        ),
      },
      ...agentsRouterConfig,
      {
        path: 'analytics',
        defaultPathIfModule: Module.INSIGHTS,
        element: (
          <Navigate
            to="/insights"
            replace
          />
        ),
      },
      {
        path: 'referral',
        defaultPathIfModule: Module.REFERRALS,
        element: <Referral />,
      },
      {
        path: 'users',
        defaultPathIfModule: Module.USERS,
        children: [
          {
            path: '',
            element: (
              <UsersGuard requiredGrants={ROUTE_GRANTS.USERS.LIST}>
                <Users />
              </UsersGuard>
            ),
          },
          {
            path: ':id',
            element: (
              <UsersGuard requiredUserGrants={ROUTE_GRANTS.USERS.DETAIL}>
                <User />
              </UsersGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <UsersGuard requiredUserGrants={ROUTE_GRANTS.USERS.DETAIL}>
                <UserEdit />
              </UsersGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <UsersGuard requiredGrants={ROUTE_GRANTS.USERS.NEW}>
                <UserEdit />
              </UsersGuard>
            ),
          },
          {
            path: ':userId/onboardings/tasks/new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.ONBOARDING}
              >
                <OnboardingsTask />
              </PermissionsGuard>
            ),
          },
          {
            path: ':userId/onboardings/tasks/:taskId/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.ONBOARDING}
              >
                <OnboardingsTask />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk',
            element: (
              <UsersGuard requiredGrants={ROUTE_GRANTS.USERS.BULK.CREATE_USERS}>
                <BulkUpload type={UsersBulkUploadTypes.BULK_CREATE_USER} />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_delete',
            element: (
              <UsersGuard requiredGrants={ROUTE_GRANTS.USERS.BULK.DELETE_USERS}>
                <BulkDelete />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_deactivate',
            element: (
              <UsersGuard
                requiredGrants={ROUTE_GRANTS.USERS.BULK.DEACTIVATE_USERS}
              >
                <BulkUpload type={UsersBulkUploadTypes.BULK_DEACTIVATE_USERS} />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_boss_assignment',
            element: (
              <UsersGuard
                requiredGrants={ROUTE_GRANTS.USERS.BULK.BOSS_ASSIGNMENT}
              >
                <BulkUpload type={UsersBulkUploadTypes.BULK_ADD_BOSSES} />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_reviewer_assignment',
            element: (
              <UsersGuard
                requiredGrants={ROUTE_GRANTS.USERS.BULK.REVIEWER_ASSIGNMENT}
              >
                <BulkUpload
                  type={UsersBulkUploadTypes.BULK_ASSIGNMENT_USER_REVIEWERS}
                />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_departments_assignment',
            element: (
              <UsersGuard
                requiredGrants={ROUTE_GRANTS.USERS.BULK.DEPARTMENT_ASSIGNMENT}
              >
                <BulkUpload
                  type={UsersBulkUploadTypes.BULK_CREATE_USER_DEPARTMENT}
                />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_positions_assignment',
            element: (
              <UsersGuard
                requiredGrants={ROUTE_GRANTS.USERS.BULK.POSITION_ASSIGNMENT}
              >
                <BulkUpload
                  type={UsersBulkUploadTypes.BULK_CREATE_USER_JOB_POSITIONS}
                />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_profile_fields',
            element: (
              <UsersGuard
                requiredGrants={ROUTE_GRANTS.USERS.BULK.UPDATE_PROFILE_FIELDS}
              >
                <BulkUpload
                  type={UsersBulkUploadTypes.BULK_UPDATE_PROFILE_FIELDS}
                />
              </UsersGuard>
            ),
          },
          {
            path: 'bulk_chats',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.USERS}>
                <BulkUploadChats />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'groups',
        defaultPathIfModule: Module.GROUPS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GROUPS}>
                <Groups />
              </PermissionsGuard>
            ),
          },
          {
            path: 'requests',
            element: (
              <PermissionsGuard
                requiredPermissions={[
                  UserPermissions.MANAGE_MULTICOMPANY_GROUPS,
                ]}
                requireAll
              >
                <GroupsCompanyInvitations />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GROUPS}>
                <NewGroup />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GROUPS}>
                <EditGroup />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/bulk',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GROUPS}>
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_ADD_MEMBERS_TO_GROUP}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: 'multicompany/invitation',
            element: (
              <PermissionsGuard
                requiredPermissions={[
                  UserPermissions.MANAGE_MULTICOMPANY_GROUPS,
                ]}
              >
                <MultiCompanyGroupInvitation />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'segmentation',
        defaultPathIfModule: Module.SEGMENTATIONS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SEGMENTATION}
              >
                <Segmentation />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk_segmentation',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SEGMENTATION}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_CREATE_SEGMENTATION_GROUP}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk_items',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SEGMENTATION}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_CREATE_SEGMENTATION_ITEM}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk_users_assignment',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SEGMENTATION}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_ASSIGNMENT_ITEMS_TO_USERS}
                />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'news',
        defaultPathIfModule: Module.ARTICLES,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.NEWS}>
                <News />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.NEWS}>
                <EditNews />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.NEWS}>
                <EditNews />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'forms',
        defaultPathIfModule: Module.FORMS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.FORMS}>
                <Forms
                  formType={FormTypes.FORM}
                  key={FormTypes.FORM}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: ':formId/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.FORMS_EDIT}
              >
                <Form />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'surveys',
        defaultPathIfModule: Module.SURVEYS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.SURVEYS}>
                <Forms
                  formType={FormTypes.SURVEY}
                  key={FormTypes.SURVEY}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: ':formId/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SURVEYS_EDIT}
              >
                <Form />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'onboarding',
        defaultPathIfModule: Module.ONBOARDINGS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.ONBOARDING}
              >
                <Onboardings />
              </PermissionsGuard>
            ),
          },
          {
            path: 'tasks',
            children: [
              {
                path: 'new',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ONBOARDING}
                  >
                    <OnboardingsTask />
                  </PermissionsGuard>
                ),
              },
              {
                path: ':taskId/edit',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ONBOARDING}
                  >
                    <OnboardingsTask />
                  </PermissionsGuard>
                ),
              },
              {
                path: ':id/quiz',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ONBOARDING}
                  >
                    <OnboardingsQuiz />
                  </PermissionsGuard>
                ),
              },
            ],
          },
        ],
      },
      // Employee Lifecycle -> New Onboarding
      {
        path: 'employee-lifecycle',
        defaultPathIfModule: Module.EMPLOYEE_LIFECYCLE,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.EMPLOYEE_LIFECYCLE}
              >
                <EmployeeLifecycle />
              </PermissionsGuard>
            ),
          },
          {
            path: 'process/:processId/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={[
                  UserPermissions.MANAGE_EMPLOYEE_LIFECYCLE,
                ]}
              >
                <EmployeeLifecycleEditProcess />
              </PermissionsGuard>
            ),
          },
          {
            path: 'process/new',
            element: (
              <PermissionsGuard
                requiredPermissions={[
                  UserPermissions.MANAGE_EMPLOYEE_LIFECYCLE,
                ]}
              >
                <EmployeeLifecycleNewProcess />
              </PermissionsGuard>
            ),
          },
          {
            path: 'process/:processId/report',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.EMPLOYEE_LIFECYCLE}
              >
                <EmployeeLifecycleProcessReport />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'acknowledgements',
        defaultPathIfModule: Module.ACKNOWLEDGEMENTS,
        children: [
          {
            path: 'categories',
            children: [
              {
                path: 'new',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ACKNOWLEDGEMENTS}
                  >
                    <AcknowledgementCategoryForm />
                  </PermissionsGuard>
                ),
              },
              {
                path: 'edit/:id',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ACKNOWLEDGEMENTS}
                  >
                    <AcknowledgementCategoryForm />
                  </PermissionsGuard>
                ),
              },
            ],
          },
          {
            path: 'products',
            children: [
              {
                path: 'new',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ACKNOWLEDGEMENTS}
                  >
                    <AcknowledgementProduct />
                  </PermissionsGuard>
                ),
              },
              {
                path: ':id',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.ACKNOWLEDGEMENTS}
                  >
                    <AcknowledgementProduct />
                  </PermissionsGuard>
                ),
              },
            ],
          },
          {
            path: 'bulk',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.USERS}>
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_ASSIGNMENT_ACKNOWLEDGEMENT}
                  showAlert
                />
              </PermissionsGuard>
            ),
          },
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.ACKNOWLEDGEMENTS}
              >
                <Acknowledgements />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'files',
        defaultPathIfModule: Module.FILES,
        children: [
          {
            path: ':id',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.FILES}>
                <Files />
              </PermissionsGuard>
            ),
          },
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.FILES}>
                <Files />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.FILES}>
                <NewFileContainer />
              </PermissionsGuard>
            ),
          },
          {
            path: ':folderId/new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.FILES}>
                <NewFileContainer />
              </PermissionsGuard>
            ),
          },
          {
            path: ':fileId/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.FILES}>
                <EditFileContainer />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'documents',
        defaultPathIfModule: Module.DOCUMENTS,
        children: [
          {
            path: ':id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.DOCUMENT}
              >
                <Documents />
              </PermissionsGuard>
            ),
          },
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.DOCUMENT}
              >
                <Documents />
              </PermissionsGuard>
            ),
          },
          {
            path: ':folderId/new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.DOCUMENT}
              >
                <DocumentsEdit />
              </PermissionsGuard>
            ),
          },
          {
            path: ':folderId/:fileId',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.DOCUMENT}
              >
                <DocumentsEdit />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.DOCUMENT}
              >
                <BulkUploadFiles />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'widgets',
        defaultPathIfModule: Module.WIDGETS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.WIDGETS}>
                <Widgets />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.WIDGETS}>
                <Widget />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.WIDGETS}>
                <Widget />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'library/*',
        defaultPathIfModule: Module.KNOWLEDGE_LIBRARIES,
        element: <LibrariesEntry />,
      },
      {
        path: 'vacations',
        defaultPathIfModule: Module.TIME_OFF,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
              >
                <Vacations />
              </PermissionsGuard>
            ),
          },

          {
            path: 'policy_types',
            children: [
              {
                path: ':id/edit',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
                  >
                    <PolicyTypeEdit />
                  </PermissionsGuard>
                ),
              },
              {
                path: 'new',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
                  >
                    <PolicyTypeEdit />
                  </PermissionsGuard>
                ),
              },
            ],
          },
          {
            path: 'conflicts',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
              >
                <VacationsConflicts />
              </PermissionsGuard>
            ),
          },
          {
            path: 'conflicts/:id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
              >
                <VacationsConflicts />
              </PermissionsGuard>
            ),
          },
          {
            path: 'policies',
            children: [
              {
                path: ':id/edit',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
                  >
                    <PolicyEdit />
                  </PermissionsGuard>
                ),
              },
              {
                path: ':id/assign-people',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
                  >
                    <CriteriaProvider>
                      <AssignPeople />
                    </CriteriaProvider>
                  </PermissionsGuard>
                ),
              },
              {
                path: ':id/bulk',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
                  >
                    <HuBulkUpload
                      type={
                        NonUserBulkUploadTypes.BULK_TIME_OFF_BALANCES_CORRECTION
                      }
                    />
                  </PermissionsGuard>
                ),
              },
              {
                path: 'new',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
                  >
                    <PolicyEdit />
                  </PermissionsGuard>
                ),
              },
            ],
          },
          {
            path: 'approvers',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
              >
                <Approvers />
              </PermissionsGuard>
            ),
          },
          {
            path: 'order',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.VACATIONS}
              >
                <OrderPolicies />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'competencies',
        defaultPathIfModule: Module.COMPETENCIES,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.COMPETENCIES}
              >
                <Competencies />
              </PermissionsGuard>
            ),
          },
          {
            path: 'profiles/:id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.COMPETENCIES}
              >
                <ManageCompetencyProfile />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'performance',
        defaultPathIfModule: Module.PERFORMANCE_REVIEWS,
        children: [
          {
            path: 'questions',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <Questions />
              </PermissionsGuard>
            ),
          },
          {
            path: 'templates',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <Templates />
              </PermissionsGuard>
            ),
          },
          {
            path: 'templates/new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <Template />
              </PermissionsGuard>
            ),
          },
          {
            path: 'templates/:id/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <Template />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <Cycles />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <CycleEdit />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <Cycle />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/calibration/new-rule',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <CalibrationRuleCreate />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/calibration/:ruleId/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}
              >
                <CalibrationRuleCreate />
              </PermissionsGuard>
            ),
          },
          /* Temporally hidden page */
          /* {
            path: 'cycles/:id/results',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.PERFORMANCE}>
                <CycleResults />
              </PermissionsGuard>
            ),
          }, */
        ],
      },
      {
        path: 'goals',
        defaultPathIfModule: Module.GOALS,
        children: [
          {
            path: 'cycles',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <GoalCycles />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <GoalEdit />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <GoalCycle />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/goal/:goalId',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <GoalDetail />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/goal/:goalId/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <EditGoal />
              </PermissionsGuard>
            ),
          },
          {
            path: 'cycles/:id/bulk',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <BulkUploadGoals />
              </PermissionsGuard>
            ),
          },
          {
            path: 'configuration',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.GOALS}>
                <GoalConfiguration />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'regions',
        defaultPathIfModule: Module.REGIONS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.REGIONS}>
                <Regions />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.REGIONS}>
                <RegionCreate />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/sites/new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.REGIONS}>
                <SiteCreate />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.REGIONS}>
                <RegionEdit />
              </PermissionsGuard>
            ),
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to="general"
                    replace
                  />
                ),
              },
              {
                path: 'general',
                element: <RegionGeneral />,
              },
              {
                path: 'holidays',
                element: <RegionHolidays />,
              },
              {
                path: 'sites',
                element: <Sites />,
              },
              {
                path: 'collaborators',
                element: <RegionCollaborators />,
              },
            ],
          },
          {
            path: ':regionId/sites/new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.REGIONS}>
                <SiteCreate />
              </PermissionsGuard>
            ),
          },
          {
            path: ':regionId/sites/:siteId',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.REGIONS}>
                <SiteEdit />
              </PermissionsGuard>
            ),
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to="general"
                    replace
                  />
                ),
              },
              {
                path: 'general',
                element: <SiteGeneral />,
              },
              {
                path: 'location',
                element: <SiteLocation />,
              },
              {
                path: 'collaborators',
                element: <SiteCollaborators />,
              },
            ],
          },
        ],
      },
      {
        path: 'prode',
        defaultPathIfModule: Module.PRODE_ADMIN,
        element: (
          <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.PRODE_ADMIN}>
            <Outlet />
          </PermissionsGuard>
        ),
        children: [
          { path: '', element: <ProdeList /> },
          { path: 'new', element: <ProdeCreate /> },
          {
            path: ':competitionId',
            element: <ProdeDetail />,
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to={prodePaths.participants}
                    replace
                  />
                ),
              },
              {
                path: prodePaths.participants,
                element: <ProdeParticipantsTab />,
              },
              { path: prodePaths.prizes, element: <ProdePrizesTab /> },
            ],
          },
        ],
      },
      ...pxRouteConfig,
      {
        path: 'settings',
        defaultPathIfModule: Module.SETTINGS,
        children: [
          {
            path: 'general',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
                cerberusRequiredPermissions={
                  ROUTE_PERMISSIONS.CERBERUS.SETTINGS
                }
              >
                <Settings />
              </PermissionsGuard>
            ),
          },
          {
            path: 'roles',
            children: [
              {
                path: '',
                element: (
                  <PermissionsGuard
                    cerberusRequiredPermissions={
                      ROUTE_PERMISSIONS.CERBERUS.ROLES_AND_PERMISSIONS_LIST
                    }
                  >
                    <RolesAndPermissions />
                  </PermissionsGuard>
                ),
              },
              {
                path: 'new',
                element: (
                  <PermissionsGuard
                    cerberusRequiredPermissions={
                      ROUTE_PERMISSIONS.CERBERUS.ROLES_AND_PERMISSIONS_NEW
                    }
                  >
                    <RoleForm />
                  </PermissionsGuard>
                ),
              },
              {
                path: ':id/edit',
                element: (
                  <PermissionsGuard
                    cerberusRequiredPermissions={
                      ROUTE_PERMISSIONS.CERBERUS.ROLES_AND_PERMISSIONS_EDIT
                    }
                  >
                    <RoleForm />
                  </PermissionsGuard>
                ),
              },
            ],
          },
          {
            path: 'security',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
                cerberusRequiredPermissions={
                  ROUTE_PERMISSIONS.CERBERUS.SECURITY
                }
              >
                <SecuritySettings />
              </PermissionsGuard>
            ),
          },
          {
            path: 'profile_fields_bulk',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_CREATE_PROFILE_FIELDS}
                />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'departments',
        defaultPathIfModule: Module.SETTINGS,
        children: [
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
                cerberusRequiredPermissions={[
                  UserPermissions.CREATE_DEPARTMENTS,
                ]}
              >
                <NewDepartment />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
                cerberusRequiredPermissions={[
                  UserPermissions.BULK_CREATE_DEPARTMENTS,
                ]}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_CREATE_DEPARTMENTS}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
                cerberusRequiredPermissions={[UserPermissions.EDIT_DEPARTMENTS]}
              >
                <EditDepartment />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk-assignment',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.USERS}
                cerberusRequiredPermissions={[
                  UserPermissions.BULK_CREATE_DEPARTMENTS,
                  UserPermissions.MANAGE_USERS,
                ]}
              >
                <BulkUpload
                  type={UsersBulkUploadTypes.BULK_CREATE_USER_DEPARTMENT}
                />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'positions',
        defaultPathIfModule: Module.SETTINGS,
        children: [
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
              >
                <NewPosition />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_CREATE_JOB_POSITIONS}
                />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
              >
                <EditPosition />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'apps',
        defaultPathIfModule: Module.MINI_APPS,
        element: (
          <PermissionsGuard
            requiredPermissions={ROUTE_PERMISSIONS.SETTINGS}
            cerberusRequiredPermissions={ROUTE_PERMISSIONS.CERBERUS.MINI_APPS}
          >
            <Apps />
          </PermissionsGuard>
        ),
      },
      {
        path: 'courses',
        defaultPathIfModule: Module.LEARNING,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.COURSES}>
                <Courses />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.COURSES}>
                <CourseNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.COURSES}>
                <CourseNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/draft',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.COURSES}>
                <CourseNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/duplicate',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.COURSES}>
                <CourseNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/report',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.COURSES}>
                <CourseReport />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'paths',
        defaultPathIfModule: Module.PATHS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.PATHS}>
                <Paths />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.PATHS}>
                <PathNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.PATHS}>
                <PathNew />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'sessions',
        defaultPathIfModule: Module.LEARNING_SESSIONS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SESSIONS}
              >
                <Sessions />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SESSIONS}
              >
                <SessionNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SESSIONS}
              >
                <SessionNew />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/manage-attendance',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SESSIONS}
              >
                <ManageSessionAttendance />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'learning/settings',
        defaultPathIfModule: Module.LEARNING_SETTINGS,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.LEARNING_SETTINGS}
                requireAll
              >
                <LearningSettings />
              </PermissionsGuard>
            ),
          },
          {
            path: 'categories',
            children: [
              {
                path: '',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.LEARNING_SETTINGS}
                    requireAll
                  >
                    <LearningSettingsCategories />
                  </PermissionsGuard>
                ),
              },
            ],
          },
          {
            path: 'certificates/*',
            element: <CertificatesEntry />,
          },
        ],
      },
      {
        path: 'service-management',
        defaultPathIfModule: Module.WORKFLOWS,
        children: [
          {
            path: 'pdf-creation',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_SERVICE_MANAGEMENT}
              >
                <PdfCreation />
              </PermissionsGuard>
            ),
          },
          {
            path: 'catalog',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_SERVICE_MANAGEMENT}
              >
                <ServiceItems />
              </PermissionsGuard>
            ),
          },
          {
            path: 'catalog/new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_SERVICE_MANAGEMENT}
                requireAll
              >
                <NewServiceItem />
              </PermissionsGuard>
            ),
          },
          {
            path: 'catalog/:id/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_SERVICE_MANAGEMENT}
                requireAll
              >
                <NewServiceItem />
              </PermissionsGuard>
            ),
          },
          {
            path: 'catalog/categories/:categoryId',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_SERVICE_MANAGEMENT}
              >
                <ServiceItems />
              </PermissionsGuard>
            ),
          },
          {
            path: 'agent-management',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_AGENT_MANAGEMENT}
              >
                <AgentManagement />
              </PermissionsGuard>
            ),
          },
          {
            path: 'agent-management/help-desks',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_AGENT_MANAGEMENT}
              >
                <HelpDesks />
              </PermissionsGuard>
            ),
          },
          {
            path: 'agent-management/agents',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_AGENT_MANAGEMENT}
              >
                <Agents />
              </PermissionsGuard>
            ),
          },
          {
            path: 'agent-management/help-desks/:helpDeskId/agent-groups/new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_AGENT_MANAGEMENT}
              >
                <CreateOrEditAgentGroup />
              </PermissionsGuard>
            ),
          },
          {
            path: 'agent-management/help-desks/:helpDeskId/agent-groups/:agentGroupId/edit',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_AGENT_MANAGEMENT}
              >
                <CreateOrEditAgentGroup />
              </PermissionsGuard>
            ),
          },
          {
            path: 'agent-management/agents/:agentId',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_AGENT_MANAGEMENT}
              >
                <AgentProfile />
              </PermissionsGuard>
            ),
          },
          {
            path: 'metrics',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.SM_METRICS}
                requireAll
              >
                <ServiceManagementMetrics />
              </PermissionsGuard>
            ),
          },
          {
            path: 'workflows',
            defaultPathIfModule: Module.WORKFLOWS,
            children: [
              {
                index: true,
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.SM_WORKFLOWS}
                  >
                    <Workflows />
                  </PermissionsGuard>
                ),
              },
              {
                path: ':id',
                element: (
                  <PermissionsGuard
                    requiredPermissions={ROUTE_PERMISSIONS.SM_WORKFLOWS}
                  >
                    <WorkflowWithProvider />
                  </PermissionsGuard>
                ),
              },
            ],
          },
        ],
      },
      {
        path: 'work-schedules',
        defaultPathIfModule: Module.WORK_SCHEDULES,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.WORK_SCHEDULES}
              >
                <WorkSchedules />
              </PermissionsGuard>
            ),
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to="list"
                    replace
                  />
                ),
              },
              {
                path: 'list',
                element: <SchedulesList />,
              },
              {
                path: 'collabs',
                element: <CollabsList />,
              },
            ],
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.WORK_SCHEDULES}
              >
                <CreateSchedule />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.WORK_SCHEDULES}
              >
                <EditWorkSchedule />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/collaborators',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.WORK_SCHEDULES}
              >
                <ScheduleAssignments />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id/collaborators/assign',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.WORK_SCHEDULES}
              >
                <EditWorkScheduleCollaborators />
              </PermissionsGuard>
            ),
          },
          {
            path: 'bulk',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.WORK_SCHEDULES}
              >
                <BulkUpload
                  type={NonUserBulkUploadTypes.BULK_UPDATE_WORK_SCHEDULES}
                />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'time-tracking/policies',
        defaultPathIfModule: Module.TIME_TRACKING,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <TimePoliciesBase />
              </PermissionsGuard>
            ),
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to="list"
                    replace
                  />
                ),
              },
              {
                path: 'list',
                element: <TimePoliciesList />,
              },
              {
                path: 'approvers',
                element: <TimePoliciesApprovers />,
              },
            ],
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <CreateTimePolicy />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <EditTimePolicy />
              </PermissionsGuard>
            ),
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to="general"
                    replace
                  />
                ),
              },
              {
                path: 'general',
                element: <TimePolicyGeneralData />,
              },
              {
                path: 'marking-methods',
                element: <TimePolicyMarkingMethods />,
              },
              {
                path: 'hours-management',
                element: <TimePolicyHoursManagement />,
              },
              {
                path: 'restrictions',
                element: <TimePolicyRestrictions />,
              },
              {
                path: 'automations',
                element: <TimePolicyAutomations />,
              },
              {
                path: 'collaborators',
                element: <TimePolicyAssignments />,
              },
              {
                path: 'approvers',
                element: <TimePolicyApprovers />,
              },
            ],
          },
        ],
      },
      {
        path: 'time-tracking/kiosk',
        defaultPathIfModule: Module.TIME_TRACKING,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <Kiosk />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <CreateKioskTerminal />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <EditKioskTerminal />
              </PermissionsGuard>
            ),
          },
          {
            path: 'link',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <LinkKioskTerminal />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'time-tracking/general-settings',
        defaultPathIfModule: Module.TIME_TRACKING,
        children: [
          {
            path: '',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <TimeTrackingSettings />
              </PermissionsGuard>
            ),
          },
          {
            path: 'new',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <CreateCategorizedHours />
              </PermissionsGuard>
            ),
          },
          {
            path: ':id',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TIME_TRACKING}
              >
                <EditCategorizedHours />
              </PermissionsGuard>
            ),
            children: [
              {
                index: true,
                element: (
                  <Navigate
                    to="general"
                    replace
                  />
                ),
              },
              {
                path: 'general',
                element: <CategorizedHoursGeneralData />,
              },
              {
                path: 'rules',
                element: <CategorizedHoursRulesTab />,
              },
            ],
          },
        ],
      },
      // Need to check if instance has community feature because it's not enough to check for roles (permissions) only
      ...insertIf(canViewCustomReports, {
        path: 'reports',
        defaultPathIfModule: Module.REPORTS,
        element: (
          <GrupoEfeGuard
            requiredRoles={[
              Roles.ACCESS_MANAGEMENT,
              Roles.INFORMATION_SECURITY,
            ]}
            cerberusRequiredPermissions={[
              UserPermissions.MANAGE_CUSTOM_REPORTS,
            ]}
          >
            <Reports />
          </GrupoEfeGuard>
        ),
      }),
      {
        path: 'communication',
        defaultPathIfModule: Module.COMMUNICATIONS,
        children: [
          {
            path: 'drafts',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.COMMUNICATION}
              >
                <DraftsForReview />
              </PermissionsGuard>
            ),
          },
          {
            path: 'create-draft-permission',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.COMMUNICATION}
              >
                <CreateDraftPermission />
              </PermissionsGuard>
            ),
          },
        ],
      },
      {
        path: 'recruiting/*',
        defaultPathIfModule: Module.ATS,
        element: (
          <PermissionsGuard requiredPermissions={ROUTE_PERMISSIONS.ATS}>
            <Recruiting />
          </PermissionsGuard>
        ),
      },
      {
        path: 'tali',
        defaultPathIfModule: Module.TALI,
        children: [
          {
            index: true,
            element: (
              <Navigate
                to="conversations"
                replace
              />
            ),
          },
          {
            path: 'conversations',
            element: (
              <PermissionsGuard
                requiredPermissions={ROUTE_PERMISSIONS.TALI}
                cerberusRequiredPermissions={ROUTE_PERMISSIONS.CERBERUS.TALI}
              >
                <RetentionConversationList />
              </PermissionsGuard>
            ),
          },
        ],
      },
    ],
  };

  const defaultPath =
    dashboardPartialRoute.children?.find(child =>
      availableModules?.includes(child.defaultPathIfModule!),
    )?.path || '';

  const defaultDashboardPartialRoute = {
    path: '',
    element: <Navigate to={`/${defaultPath}`} />,
    defaultPathIf: null,
  };
  dashboardPartialRoute.children?.push(defaultDashboardPartialRoute);

  return [
    dashboardPartialRoute,
    {
      path: 'tali/conversations/:id',
      element: (
        <AuthGuard>
          <PermissionsGuard
            requiredPermissions={ROUTE_PERMISSIONS.TALI}
            cerberusRequiredPermissions={ROUTE_PERMISSIONS.CERBERUS.TALI}
          >
            <RetentionConversationDetail />
          </PermissionsGuard>
        </AuthGuard>
      ),
    },
    {
      path: 'authentication',
      children: [
        {
          path: 'login',
          element: (
            <GuestGuard>
              <Login />
            </GuestGuard>
          ),
        },
        {
          path: 'otp',
          element: (
            <GuestGuard>
              <LoginOTP />
            </GuestGuard>
          ),
        },
      ],
    },
    {
      path: '*',
      children: [
        {
          path: '*',
          element: (
            <Navigate
              to="/"
              replace
            />
          ),
        },
      ],
    },
  ];
};

export default getRoutes;