@acorex-platform/module-locale-management-client 0.0.21

package/fesm2022/acorex-platform-module-locale-management-client.mjs

@@ -0,0 +1,1251 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, signal, ChangeDetectionStrategy, Component, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i1$1 from '@acorex-platform/framework-client/core';
+import { objectKeyValueTransforms, AXP_APP_STARTUP_PRIORITY, AXPComponentSlotModule, AXP_MODULE_MANIFEST_PROVIDER, AXP_CONTEXT_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/core';
+import { provideQuerySetups } from '@acorex-platform/framework-client/runtime';
+import { RootConfig, getLocaleProfileCatalogCodes, AXPApplicationsPlatformPermissionKeys, AXPLocaleManagementMenuKeys } from '@acorex-platform/module-locale-management-client/contracts';
+import * as i3 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i1 from '@acorex/components/dropdown';
+import { AXDropdownModule } from '@acorex/components/dropdown';
+import { AXPopoverModule } from '@acorex/components/popover';
+import { AXPRegionalSetting, AXPPlatformScope, AXPWidgetsList, AXPWidgetsCatalog } from '@acorex-platform/framework-shared/core';
+import { AXPSettingsService, resolveEffectiveAvailableLanguageCodes, AXPSearchCommandProvider, createEntityCommandOptions, AXPPlatformSettingsLoadState, AXP_LOCALE_MANAGEMENT_PORT, AXPRegionalCalendarService, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXCalendarService } from '@acorex/core/date-time';
+import { AXLocaleService, AX_LOCALE_PROFILE_PROVIDERS } from '@acorex/core/locale';
+import { AXTranslationService } from '@acorex/core/translation';
+import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPCommonPermissionGroupKeys, AXPCommonMenuKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXM_LOCALE_CONTEXT_DEFINITIONS } from '@acorex-platform/module-locale-management-contracts';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Locale Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const LocaleManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'platform',
+    domain: 'platform',
+    required: true,
+    // Module dependencies (optional)
+};
+//#endregion
+
+const REGIONAL_SETTING_KEYS = [
+    AXPRegionalSetting.LocaleProfile,
+    AXPRegionalSetting.Language,
+    AXPRegionalSetting.Calendar,
+];
+// Regional Store - Manages regional settings and system changes
+const AXPRegionalStoreService = signalStore({ providedIn: 'root' }, 
+// Initial State
+withState(() => {
+    // Initialize with safe defaults - actual values will be loaded via loadSetting()
+    const state = {
+        profile: null,
+        language: null,
+        calendar: null,
+    };
+    return state;
+}), 
+// Computed Signals
+// withComputed(({ }) => ({
+// })),
+// Methods for State Management
+withMethods((store, settingsService = inject(AXPSettingsService), localeService = inject(AXLocaleService), calendarService = inject(AXCalendarService), translateService = inject(AXTranslationService)) => {
+    const applyChanges = async () => {
+        const profile = localeService.activeProfile();
+        const html = document.getElementsByTagName('html')[0];
+        profile.i18nMeta?.rtl ? html.setAttribute('dir', 'rtl') : html.removeAttribute('dir');
+    };
+    const applyProfileFormats = async (profile) => {
+        const date = profile.formats?.date;
+        if (date?.short) {
+            await settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.ShortDate, date.short);
+        }
+        if (date?.medium) {
+            await settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.MediumDate, date.medium);
+        }
+        if (date?.long) {
+            await settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.LongDate, date.long);
+        }
+        const time = profile.formats?.time;
+        if (time?.short) {
+            await settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.ShortTime, time.short);
+        }
+        if (time?.medium) {
+            await settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.MediumTime, time.medium);
+        }
+        if (time?.long) {
+            await settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.LongTime, time.long);
+        }
+    };
+    return {
+        async changeProfile(profileCode) {
+            await localeService.setProfile(profileCode);
+            const profile = localeService.activeProfile();
+            if (store.profile() != profile.localeInfo.code) {
+                settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.LocaleProfile, profile.localeInfo.code);
+                settingsService.scope(AXPPlatformScope.User).set(AXPRegionalSetting.Language, profile.localeInfo.code);
+                patchState(store, { profile: profile.localeInfo.code });
+            }
+            await applyProfileFormats(profile);
+            await applyChanges();
+        },
+        /**
+         * Applies effective regional settings (user → tenant → platform) to locale, calendar, i18n, and document direction.
+         */
+        async loadSetting() {
+            const profileCode = (await settingsService.get(AXPRegionalSetting.LocaleProfile)) || 'en-US';
+            patchState(store, { profile: profileCode });
+            if (profileCode) {
+                await localeService.setProfile(profileCode);
+            }
+            const calendar = (await settingsService.get(AXPRegionalSetting.Calendar));
+            if (calendar) {
+                patchState(store, { calendar });
+                calendarService.setActiveCalendar(calendar);
+            }
+            const language = (await settingsService.get(AXPRegionalSetting.Language));
+            if (language) {
+                patchState(store, { language });
+                translateService.setActiveLang(language);
+            }
+            await applyChanges();
+        },
+    };
+}), withHooks((store, settingsService = inject(AXPSettingsService)) => ({
+    onInit() {
+        settingsService.onLoaded.subscribe(() => {
+            void store.loadSetting();
+        });
+        settingsService.onChanged.subscribe(async (setting) => {
+            if (REGIONAL_SETTING_KEYS.some((k) => setting.keys.includes(k))) {
+                await store.loadSetting();
+            }
+        });
+    },
+    onDestroy() { },
+})));
+
+/** Simple cache - timezones are static reference data */
+let timezonesCache = null;
+/** Dedupes concurrent bootstrap callers so a failed/slow query cannot storm the API. */
+let timezonesLoadPromise = null;
+class AXMLocaleManagementService {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.settingsService = inject(AXPSettingsService);
+        this.languagesDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.languages.name)
+            .data();
+        this.timezonesDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.timezones.name)
+            .data();
+        this.localesDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.locales.name)
+            .data();
+        this.activeQuery = {
+            skip: 0,
+            take: 1000,
+            filter: {
+                logic: 'and',
+                filters: [
+                    {
+                        field: 'isActive',
+                        operator: {
+                            type: 'equal',
+                        },
+                        value: true,
+                    },
+                ],
+            },
+            sort: [
+                {
+                    field: 'title',
+                    dir: 'asc',
+                },
+            ],
+        };
+    }
+    async getLocaleProfiles() {
+        const { profiles } = await import('./acorex-platform-module-locale-management-client-profiles-l46U-cgo.mjs');
+        const catalogCodes = getLocaleProfileCatalogCodes();
+        if (!catalogCodes?.length) {
+            return profiles;
+        }
+        const allowSet = new Set(catalogCodes);
+        const filtered = profiles.filter((profile) => allowSet.has(profile.code));
+        return filtered.length > 0 ? filtered : profiles;
+    }
+    async getAvailableLocaleProfiles() {
+        const profiles = await this.getLocaleProfiles();
+        const allowed = await resolveEffectiveAvailableLanguageCodes(this.settingsService);
+        if (allowed.length === 0) {
+            return profiles;
+        }
+        const allowSet = new Set(allowed);
+        return profiles.filter((profile) => allowSet.has(profile.code));
+    }
+    async getLanguages() {
+        const result = await this.languagesDataAccessor.query(this.activeQuery);
+        return result.items.map((c) => ({
+            code: c.code,
+            title: c.title,
+        }));
+    }
+    async getLocales() {
+        const result = await this.localesDataAccessor.query(this.activeQuery);
+        return result.items.map((c) => ({
+            code: c.code,
+            title: c.title,
+        }));
+    }
+    async getAvailableLanguages() {
+        const profiles = await this.getAvailableLocaleProfiles();
+        return profiles.map((profile) => ({
+            code: profile.code,
+            title: profile.title,
+        }));
+    }
+    async getTimeZones() {
+        if (timezonesCache) {
+            return timezonesCache;
+        }
+        if (!timezonesLoadPromise) {
+            timezonesLoadPromise = this.loadTimeZones().finally(() => {
+                timezonesLoadPromise = null;
+            });
+        }
+        return timezonesLoadPromise;
+    }
+    async getBrowserTimeZoneCode() {
+        // Prefer browser IANA zone — no network needed during app bootstrap / login.
+        const browserIana = typeof Intl !== 'undefined'
+            ? Intl.DateTimeFormat().resolvedOptions().timeZone
+            : undefined;
+        if (browserIana) {
+            return browserIana;
+        }
+        try {
+            const timeZones = await this.getTimeZones();
+            const offsetMinutes = new Date().getTimezoneOffset() * -1;
+            const matchedZone = timeZones.find((zone) => zone.offset === offsetMinutes);
+            return matchedZone?.code ?? 'UTC';
+        }
+        catch {
+            return 'UTC';
+        }
+    }
+    async loadTimeZones() {
+        try {
+            const result = await this.timezonesDataAccessor.query({
+                ...this.activeQuery,
+                sort: [{ field: 'standardOffset', dir: 'asc' }],
+            });
+            const padZero = (value) => value.toString().padStart(2, '0');
+            const formatOffset = (offset) => {
+                const sign = offset > 0 ? '+' : '-';
+                const hours = padZero(Math.floor(Math.abs(offset) / 60));
+                const minutes = padZero(Math.abs(offset % 60));
+                return `${sign}${hours}:${minutes}`;
+            };
+            timezonesCache = result.items.map((c) => ({
+                code: c.code,
+                title: `${c.title} (${formatOffset(c.standardOffset)})`,
+                offset: c.standardOffset,
+                iana: c.code,
+                abbr: c.abbreviation,
+            }));
+            return timezonesCache;
+        }
+        catch {
+            // Do not cache failures — allow retry after login when auth is available.
+            return [];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXMLanguageSlotComponent {
+    constructor() {
+        this.localeManagementService = inject(AXMLocaleManagementService);
+        this.store = inject(AXPRegionalStoreService);
+        this.items = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
+    }
+    async ngOnInit() {
+        const items = await this.localeManagementService.getAvailableLocaleProfiles();
+        this.items.set(items);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLanguageSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMLanguageSlotComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: "<ax-button color=\"primary\">\n  <ax-icon class=\"fa-regular fa-globe\"> </ax-icon>\n  <ax-dropdown-panel>\n    <ax-button-item-list>\n      @for(lang of items(); track lang){\n      <ax-button-item\n        [text]=\"lang.title\"\n        [selected]=\"store.profile() === lang.code\"\n        (onClick)=\"store.changeProfile(lang.code)\"\n      >\n        <ax-prefix>\n          <ax-icon icon=\"fa-solid fa-flag\"> </ax-icon>\n        </ax-prefix>\n      </ax-button-item>\n      }\n    </ax-button-item-list>\n  </ax-dropdown-panel>\n</ax-button>\n", dependencies: [{ kind: "ngmodule", type: AXDropdownModule }, { kind: "component", type: i1.AXDropdownPanelComponent, selector: "ax-dropdown-panel", inputs: ["isOpen", "fitParent", "dropdownWidth", "position", "placement", "_target", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i2.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i3.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: i3.AXButtonItemComponent, selector: "ax-button-item", inputs: ["color", "disabled", "text", "selected", "divided", "data", "name"], outputs: ["onClick", "onFocus", "onBlur", "disabledChange"] }, { kind: "component", type: i3.AXButtonItemListComponent, selector: "ax-button-item-list", inputs: ["items", "closeParentOnClick", "lockOnLoading"], outputs: ["onItemClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLanguageSlotComponent, decorators: [{
+            type: Component,
+            args: [{ imports: [AXDropdownModule, AXDecoratorModule, AXPopoverModule, AXButtonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ax-button color=\"primary\">\n  <ax-icon class=\"fa-regular fa-globe\"> </ax-icon>\n  <ax-dropdown-panel>\n    <ax-button-item-list>\n      @for(lang of items(); track lang){\n      <ax-button-item\n        [text]=\"lang.title\"\n        [selected]=\"store.profile() === lang.code\"\n        (onClick)=\"store.changeProfile(lang.code)\"\n      >\n        <ax-prefix>\n          <ax-icon icon=\"fa-solid fa-flag\"> </ax-icon>\n        </ax-prefix>\n      </ax-button-item>\n      }\n    </ax-button-item-list>\n  </ax-dropdown-panel>\n</ax-button>\n" }]
+        }] });
+
+/**
+ * Custom locale profile provider that integrates with the locale-management module
+ * to provide profiles from the platform's data instead of the default UI library profiles
+ */
+class AXMLocaleProfileProviderService {
+    constructor() {
+        this.localeManagementService = inject(AXMLocaleManagementService);
+    }
+    /**
+     * Provides locale profiles from the locale-management module
+     * This allows the platform to override the default UI library profiles
+     */
+    async provide() {
+        try {
+            // Get profiles from the locale-management module
+            const profiles = await this.localeManagementService.getLocaleProfiles();
+            // Convert to the format expected by the UI library
+            const result = {};
+            for (const profile of profiles) {
+                try {
+                    // Convert AXPLocaleProfile to AXLocaleProfile (remove platform-specific properties)
+                    const coreProfile = {
+                        localeInfo: profile.localeInfo,
+                        calendar: profile.calendar,
+                        formats: profile.formats,
+                        units: profile.units,
+                        i18nMeta: profile.i18nMeta,
+                    };
+                    // Validate that the profile has all required properties
+                    if (this.isValidProfile(coreProfile)) {
+                        // Store the profile with lazy loading for better performance
+                        result[profile.code] = () => Promise.resolve(coreProfile);
+                    }
+                    else {
+                        console.warn(`[AXMLocaleProfileProviderService] Profile ${profile.code} is missing required properties, skipping`);
+                    }
+                }
+                catch (profileError) {
+                    console.error(`[AXMLocaleProfileProviderService] Error processing profile ${profile.code}:`, profileError);
+                }
+            }
+            if (Object.keys(result).length === 0) {
+                console.warn('[AXMLocaleProfileProviderService] No valid profiles found, falling back to default behavior');
+            }
+            else {
+                //console.log(`[AXMLocaleProfileProviderService] Successfully loaded ${Object.keys(result).length} profiles:`, Object.keys(result));
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('[AXMLocaleProfileProviderService] Failed to load profiles:', error);
+            // Fallback to empty result if loading fails
+            return {};
+        }
+    }
+    /**
+     * Validates that a profile has all required properties
+     */
+    isValidProfile(profile) {
+        return (profile &&
+            profile.localeInfo &&
+            profile.calendar &&
+            profile.formats &&
+            profile.units &&
+            typeof profile.localeInfo.code === 'string' &&
+            typeof profile.localeInfo.language === 'string');
+    }
+    /**
+     * Gets the list of available locale codes from the locale-management module
+     * This can be used by other services to check available locales
+     */
+    async getAvailableLocaleCodes() {
+        try {
+            const profiles = await this.localeManagementService.getLocaleProfiles();
+            return profiles.map(p => p.code);
+        }
+        catch (error) {
+            console.error('[AXMLocaleProfileProviderService] Failed to get available locale codes:', error);
+            return [];
+        }
+    }
+    /**
+     * Checks if a specific locale is available
+     */
+    async hasLocale(localeCode) {
+        try {
+            const codes = await this.getAvailableLocaleCodes();
+            return codes.includes(localeCode);
+        }
+        catch (error) {
+            console.error(`[AXMLocaleProfileProviderService] Failed to check locale ${localeCode}:`, error);
+            return false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleProfileProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleProfileProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleProfileProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#endregion
+//#region ---- Permission Definition Provider ----
+/**
+ * Registers MaintainLocales under Applications & Platform.
+ */
+class AXMLocaleManagementPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPApplicationsPlatformPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:applications-platform.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.ApplicationsPlatform.Root, `${G}.applications-platform.title`, `${G}.applications-platform.description`, { order: 110 });
+        context
+            .addGroup(groups.ApplicationsPlatform.Configuration, `${G}.applications-platform-configuration.title`, `${G}.applications-platform-configuration.description`, { parent: groups.ApplicationsPlatform.Root, order: 30 })
+            .addPermission(keys.MaintainLocales, `${P}.maintain-locales.title`, `${P}.maintain-locales.description`, {
+            modules: ['LocaleManagement'],
+            requiredFeatures: ['LocaleManagement'],
+        })
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMLocaleManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const maintainLocales = AXPApplicationsPlatformPermissionKeys.MaintainLocales;
+        // Languages under Configuration/Region
+        context.find(AXPCommonMenuKeys.Region).addItems([
+            {
+                name: AXPLocaleManagementMenuKeys.Languages,
+                text: '@locale-management:languages.menus.languages.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.languages.name),
+                icon: RootConfig.entities.languages.icon,
+                priority: 3,
+                policy: {
+                    features: [module.name],
+                    permissions: [maintainLocales],
+                },
+            },
+        ]);
+        // Timezones under Configuration/Date and Time
+        context.find(AXPCommonMenuKeys.DateAndTime).addItems([
+            {
+                name: AXPLocaleManagementMenuKeys.Timezones,
+                text: '@locale-management:timezones.menus.timezones.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.timezones.name),
+                icon: RootConfig.entities.timezones.icon,
+                priority: 1,
+                policy: {
+                    features: [module.name],
+                    permissions: [maintainLocales],
+                },
+            },
+        ]);
+    }
+}
+
+class AXMRegionalSettingProvider {
+    constructor(injector) {
+        this.injector = injector;
+        this.regionalService = this.injector.get(AXMLocaleManagementService);
+        this.translateService = this.injector.get(AXTranslationService);
+    }
+    async provide(context) {
+        const i18n = (key) => `@locale-management:settings.settings.regional.${key}`;
+        const profiles = await this.regionalService.getLocaleProfiles();
+        const defaultProfile = profiles.find((p) => p.code === 'en-US');
+        const defaultAvailableLanguages = profiles.map((p) => p.code);
+        const multipleLanguagesVisibility = `{{ ((await settings.get('${AXPRegionalSetting.AvailableLanguages}')) || []).length > 1 }}`;
+        context
+            .addGroup('regional-settings', i18n('nav-title'), i18n('description'), 'fa-light fa-earth-americas', i18n('title'), 30)
+            // Date & Time Section
+            .addSection('date-time', i18n('datetime.title'), i18n('datetime.description'))
+            .addSetting({
+            key: AXPRegionalSetting.TimeZone,
+            title: i18n('datetime.timezone.title'),
+            scope: 'T',
+            overridableAt: ['U'],
+            isInherited: true,
+            defaultValue: 'UTC',
+            valueTransforms: objectKeyValueTransforms('code'),
+            widget: {
+                type: AXPWidgetsList.Editors.LookupBox,
+                options: {
+                    entity: 'LocaleManagement.Timezones',
+                    look: 'select',
+                    allowSearch: true,
+                    valueField: 'code',
+                    textField: 'title',
+                    filter: {
+                        logic: 'and',
+                        filters: [{ field: 'isActive', operator: { type: 'equal' }, value: true }],
+                    },
+                },
+            },
+            description: i18n('datetime.timezone.description'),
+        })
+            .endSection()
+            // Region Section
+            .addSection('region', i18n('region.title'), i18n('region.description'))
+            .addSetting({
+            key: AXPRegionalSetting.AvailableLanguages,
+            title: i18n('region.available-languages.title'),
+            scope: 'P',
+            overridableAt: ['T'],
+            isInherited: true,
+            defaultValue: defaultAvailableLanguages,
+            widget: {
+                type: AXPWidgetsList.Editors.SelectionList,
+                options: {
+                    multiple: true,
+                    valueField: 'code',
+                    textField: 'title',
+                    dataSource: 'LocaleManagement:ListLocaleProfiles',
+                },
+            },
+            description: i18n('region.available-languages.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.LocaleProfile,
+            title: i18n('region.format.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.code,
+            valueTransforms: objectKeyValueTransforms('code'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'code',
+                    textField: 'title',
+                    dataSource: 'LocaleManagement:ListAvailableLocaleProfiles',
+                    visibility: multipleLanguagesVisibility,
+                },
+            },
+            description: i18n('region.format.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.Language,
+            title: i18n('region.language.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: await this.translateService.getDefaultLang(),
+            valueTransforms: objectKeyValueTransforms('code'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'code',
+                    textField: 'title',
+                    dataSource: 'LocaleManagement:ListAvailableLocaleProfiles',
+                    visibility: multipleLanguagesVisibility,
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: `{{ widget.setValue(context.eval('${AXPRegionalSetting.LocaleProfile}')) }}`,
+                    },
+                ],
+            },
+            description: i18n('region.language.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.Calendar,
+            title: i18n('region.calendar.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.calendar.system,
+            valueTransforms: objectKeyValueTransforms('id'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'id',
+                    textField: 'title',
+                    dataSource: 'CalendarManagement:ListCalendarSystems',
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').calendar.system) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('region.calendar.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.CalendarEvents,
+            title: i18n('region.calendar-events.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: [],
+            widget: {
+                type: AXPWidgetsList.Editors.LookupBox,
+                options: {
+                    entity: 'CalendarManagement.Calendar',
+                    look: 'select',
+                    multiple: true,
+                    valueField: 'id',
+                    textField: 'title',
+                    filter: {
+                        logic: 'or',
+                        filters: [
+                            { field: 'isArchived', operator: { type: 'equal' }, value: false },
+                            { field: 'isArchived', operator: { type: 'isNull' } },
+                        ],
+                    },
+                },
+            },
+            description: i18n('region.calendar-events.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.FirstDayOfWeek,
+            title: i18n('region.firstday.title'),
+            scope: 'T',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaultProfile.calendar.week.startsOn,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: [
+                        {
+                            text: i18n('region.firstday.options.saturday'),
+                            value: 6,
+                        },
+                        {
+                            text: i18n('region.firstday.options.sunday'),
+                            value: 0,
+                        },
+                        {
+                            text: i18n('region.firstday.options.monday'),
+                            value: 1,
+                        },
+                    ],
+                    triggers: [
+                        {
+                            event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                            action: [
+                                `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').calendar.week.startsOn) }}`,
+                            ],
+                        },
+                    ],
+                },
+            },
+            description: i18n('region.firstday.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.WeekendDays,
+            title: i18n('region.workdays.title'),
+            scope: 'T',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaultProfile.calendar.week.weekends,
+            widget: {
+                type: AXPWidgetsList.Editors.SelectionList,
+                options: {
+                    multiple: true,
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: [
+                        { text: i18n('region.workdays.options.monday'), value: 1 },
+                        { text: i18n('region.workdays.options.tuesday'), value: 2 },
+                        { text: i18n('region.workdays.options.wednesday'), value: 3 },
+                        { text: i18n('region.workdays.options.thursday'), value: 4 },
+                        { text: i18n('region.workdays.options.friday'), value: 5 },
+                        { text: i18n('region.workdays.options.saturday'), value: 6 },
+                        { text: i18n('region.workdays.options.sunday'), value: 0 },
+                    ],
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').calendar.week.weekends) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('region.workdays.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.MultiLanguageSupport,
+            title: i18n('region.multilanguage-support.title'),
+            scope: 'T',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: false,
+            widget: {
+                type: AXPWidgetsCatalog.toggle,
+                options: {
+                    label: null,
+                },
+            },
+            description: i18n('region.multilanguage-support.description'),
+        })
+            // .addSetting({
+            //   key: AXPRegionalSetting.ShortDate,
+            //   title: i18n('region.shortdate.title'),
+            //   scope: 'U',
+            //   isInherited: true,
+            //   defaultValue: defaultProfile.formats.date.medium,
+            //   valueTransforms: objectKeyValueTransforms('value'),
+            //   widget: {
+            //     type: AXPWidgetsList.Editors.SelectBox,
+            //     options: {
+            //       valueField: 'value',
+            //       textField: 'text',
+            //       dataSource: await Promise.all(
+            //         profiles.map(async (c) => ({
+            //           text: `${c.formats.date.medium} (${await this.formatService.format(new Date(), 'datetime', { format: c.formats.date.medium })})`,
+            //           value: c.formats.date.medium,
+            //         })),
+            //       ),
+            //     },
+            //     triggers: [
+            //       {
+            //         event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+            //         action: [
+            //           `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').formats.date.short) }}`,
+            //         ],
+            //       },
+            //     ],
+            //   },
+            //   description: i18n('region.shortdate.description'),
+            // })
+            // .addSetting({
+            //   key: AXPRegionalSetting.LongDate,
+            //   title: i18n('region.longdate.title'),
+            //   scope: 'U',
+            //   isInherited: true,
+            //   defaultValue: defaultProfile.formats.date.long,
+            //   valueTransforms: objectKeyValueTransforms('value'),
+            //   widget: {
+            //     type: AXPWidgetsList.Editors.SelectBox,
+            //     options: {
+            //       valueField: 'value',
+            //       textField: 'text',
+            //       dataSource: await Promise.all(
+            //         profiles.map(async (c) => ({
+            //           text: `${c.formats.date.long} (${await this.formatService.format(new Date(), 'datetime', { format: c.formats.date.long })})`,
+            //           value: c.formats.date.long,
+            //         })),
+            //       ),
+            //     },
+            //     triggers: [
+            //       {
+            //         event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+            //         action: [
+            //           `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').formats.date.long) }}`,
+            //         ],
+            //       },
+            //     ],
+            //   },
+            //   description: i18n('region.longdate.description'),
+            // })
+            // .addSetting({
+            //   key: AXPRegionalSetting.ShortTime,
+            //   title: i18n('region.shorttime.title'),
+            //   scope: 'U',
+            //   isInherited: true,
+            //   defaultValue: defaultProfile.formats.time.short,
+            //   valueTransforms: objectKeyValueTransforms('value'),
+            //   widget: {
+            //     type: AXPWidgetsList.Editors.SelectBox,
+            //     options: {
+            //       valueField: 'value',
+            //       textField: 'text',
+            //       dataSource: await Promise.all(
+            //         profiles.map(async (c) => ({
+            //           text: `${c.formats.time.short} (${await this.formatService.format(new Date(), 'datetime', { format: c.formats.time.short })})`,
+            //           value: c.formats.time.short,
+            //         })),
+            //       ),
+            //     },
+            //     triggers: [
+            //       {
+            //         event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+            //         action: [
+            //           `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').formats.time.short) }}`,
+            //         ],
+            //       },
+            //     ],
+            //   },
+            //   description: i18n('region.shorttime.description'),
+            // })
+            // .addSetting({
+            //   key: AXPRegionalSetting.LongTime,
+            //   title: i18n('region.longtime.title'),
+            //   scope: 'U',
+            //   isInherited: true,
+            //   defaultValue: defaultProfile.formats.time.long,
+            //   valueTransforms: objectKeyValueTransforms('value'),
+            //   widget: {
+            //     type: AXPWidgetsList.Editors.SelectBox,
+            //     options: {
+            //       valueField: 'value',
+            //       textField: 'text',
+            //       dataSource: await Promise.all(
+            //         profiles.map(async (c) => ({
+            //           text: `${c.formats.time.long} (${await this.formatService.format(new Date(), 'datetime', { format: c.formats.time.long })})`,
+            //           value: c.formats.time.long,
+            //         })),
+            //       ),
+            //     },
+            //     triggers: [
+            //       {
+            //         event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+            //         action: [
+            //           `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').formats.time.long) }}`,
+            //         ],
+            //       },
+            //     ],
+            //   },
+            //   description: i18n('region.longtime.description'),
+            // })
+            .endSection()
+            // Unit Settings Section
+            .addSection('units', i18n('units.title'), i18n('units.description'))
+            .addSetting({
+            key: AXPRegionalSetting.TemperatureUnits,
+            title: i18n('units.temperature.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.units.temperature,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: profiles.map((c) => ({
+                        text: i18n(`units.temperature.options.${c.units.temperature}`),
+                        value: c.units.temperature,
+                    })),
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').units.temperature) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('units.temperature.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.DistanceUnits,
+            title: i18n('units.distance.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.units.distance,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: profiles.map((c) => ({
+                        text: i18n(`units.distance.options.${c.units.distance}`),
+                        value: c.units.distance,
+                    })),
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').units.distance) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('units.distance.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.WeightUnits,
+            title: i18n('units.weight.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.units.weight,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: profiles.map((c) => ({
+                        text: i18n(`units.weight.options.${c.units.weight}`),
+                        value: c.units.weight,
+                    })),
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').units.weight) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('units.weight.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.VolumeUnits,
+            title: i18n('units.volume.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.units.volume,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: [
+                        { text: i18n('units.volume.options.liters'), value: 'liters' },
+                        { text: i18n('units.volume.options.gallons'), value: 'gallons' },
+                    ],
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').units.volume) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('units.volume.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.SpeedUnits,
+            title: i18n('units.speed.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.units.speed,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: profiles.map((c) => ({
+                        text: i18n(`units.speed.options.${c.units.speed}`),
+                        value: c.units.speed,
+                    })),
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').units.speed) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('units.speed.description'),
+        })
+            .addSetting({
+            key: AXPRegionalSetting.AreaUnits,
+            title: i18n('units.area.title'),
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: defaultProfile.units.area,
+            valueTransforms: objectKeyValueTransforms('value'),
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: profiles.map((c) => ({
+                        text: i18n(`units.area.options.${c.units.area}`),
+                        value: c.units.area,
+                    })),
+                },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.LocaleProfile}') }}`,
+                        action: [
+                            `{{ widget.setValue(widget.find('${AXPRegionalSetting.LocaleProfile}').output('item').units.area) }}`,
+                        ],
+                    },
+                ],
+            },
+            description: i18n('units.area.description'),
+        })
+            .endSection()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRegionalSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRegionalSettingProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRegionalSettingProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class AXMLocaleManagementSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                id: 'create-language',
+                group: 'command',
+                title: 'New Language',
+                icon: RootConfig.entities.languages.icon,
+                description: 'Create a new language with locales.',
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.languages.name}`, {
+                        name: RootConfig.entities.languages.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.languages.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-timezone',
+                group: 'command',
+                title: 'New Timezone',
+                icon: RootConfig.entities.timezones.icon,
+                description: 'Create a new timezone definition.',
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.timezones.name}`, {
+                        name: RootConfig.entities.timezones.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.timezones.title,
+                    }),
+                },
+            },
+        ];
+    }
+}
+
+//#region ---- Locale & regional context definitions ----
+class AXMLocaleManagementContextDefinitionProvider {
+    async items() {
+        return AXM_LOCALE_CONTEXT_DEFINITIONS;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementContextDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementContextDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementContextDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+/** Hide the header language switch when the tenant allow-list has at most one profile. */
+const LANGUAGE_SLOT_VISIBLE_WHEN_MULTIPLE = `{{ ((await settings.get('${AXPRegionalSetting.AvailableLanguages}')) || []).length > 1 }}`;
+class AXMLocaleManagementModule {
+    constructor(appInitService, injector) {
+        const service = injector.get(AXPRegionalStoreService);
+        const platformSettingsLoadState = injector.get(AXPPlatformSettingsLoadState);
+        appInitService.registerTask({
+            name: 'regional-settings',
+            statusText: '@locale-management:app-startup.applying-regional-settings',
+            priority: AXP_APP_STARTUP_PRIORITY.regionalSettings,
+            run: async () => {
+                if (platformSettingsLoadState.hasFailure() ||
+                    platformSettingsLoadState.hasPendingOfflineContinue() ||
+                    platformSettingsLoadState.isOfflineMode()) {
+                    return;
+                }
+                await service.loadSetting();
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementModule, deps: [{ token: i1$1.AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementModule, imports: [CommonModule, i1$1.AXPComponentSlotModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementModule, providers: [
+            {
+                provide: AXP_LOCALE_MANAGEMENT_PORT,
+                useExisting: AXMLocaleManagementService,
+            },
+            // Module-specific providers (not part of manifest system)
+            {
+                provide: AX_LOCALE_PROFILE_PROVIDERS,
+                useClass: AXMLocaleProfileProviderService,
+                multi: true,
+            },
+            {
+                provide: AXCalendarService,
+                useClass: AXPRegionalCalendarService,
+            },
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: LocaleManagementManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMLocaleManagementPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMLocaleManagementMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMRegionalSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMLocaleManagementSearchCommandProvider,
+                multi: true,
+            },
+            provideQuerySetups([
+                {
+                    key: 'LocaleManagement:ListLocaleProfiles',
+                    loader: () => import('./acorex-platform-module-locale-management-client-list-locale-profiles.query-D_PLL72r.mjs').then((c) => c.AXMListLocaleProfilesQuery),
+                },
+                {
+                    key: 'LocaleManagement:ListAvailableLocaleProfiles',
+                    loader: () => import('./acorex-platform-module-locale-management-client-list-available-locale-profiles.query-30KT5v3V.mjs').then((c) => c.AXMListAvailableLocaleProfilesQuery),
+                },
+            ]),
+            {
+                provide: AXP_CONTEXT_DEFINITION_PROVIDER,
+                useClass: AXMLocaleManagementContextDefinitionProvider,
+                multi: true,
+            },
+        ], imports: [CommonModule,
+            AXPComponentSlotModule.forChild({
+                'root-header-end': [
+                    {
+                        name: 'language',
+                        component: AXMLanguageSlotComponent,
+                        condition: LANGUAGE_SLOT_VISIBLE_WHEN_MULTIPLE,
+                    },
+                ],
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLocaleManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        AXPComponentSlotModule.forChild({
+                            'root-header-end': [
+                                {
+                                    name: 'language',
+                                    component: AXMLanguageSlotComponent,
+                                    condition: LANGUAGE_SLOT_VISIBLE_WHEN_MULTIPLE,
+                                },
+                            ],
+                        }),
+                    ],
+                    providers: [
+                        {
+                            provide: AXP_LOCALE_MANAGEMENT_PORT,
+                            useExisting: AXMLocaleManagementService,
+                        },
+                        // Module-specific providers (not part of manifest system)
+                        {
+                            provide: AX_LOCALE_PROFILE_PROVIDERS,
+                            useClass: AXMLocaleProfileProviderService,
+                            multi: true,
+                        },
+                        {
+                            provide: AXCalendarService,
+                            useClass: AXPRegionalCalendarService,
+                        },
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: LocaleManagementManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMLocaleManagementPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMLocaleManagementMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMRegionalSettingProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXMLocaleManagementSearchCommandProvider,
+                            multi: true,
+                        },
+                        provideQuerySetups([
+                            {
+                                key: 'LocaleManagement:ListLocaleProfiles',
+                                loader: () => import('./acorex-platform-module-locale-management-client-list-locale-profiles.query-D_PLL72r.mjs').then((c) => c.AXMListLocaleProfilesQuery),
+                            },
+                            {
+                                key: 'LocaleManagement:ListAvailableLocaleProfiles',
+                                loader: () => import('./acorex-platform-module-locale-management-client-list-available-locale-profiles.query-30KT5v3V.mjs').then((c) => c.AXMListAvailableLocaleProfilesQuery),
+                            },
+                        ]),
+                        {
+                            provide: AXP_CONTEXT_DEFINITION_PROVIDER,
+                            useClass: AXMLocaleManagementContextDefinitionProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i1$1.AXPAppStartUpService }, { type: i0.Injector }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMLocaleManagementMenuProvider, AXMLocaleManagementModule, AXMLocaleManagementPermissionDefinitionProvider, AXMLocaleManagementSearchCommandProvider, AXMLocaleManagementService, AXMLocaleProfileProviderService };
+//# sourceMappingURL=acorex-platform-module-locale-management-client.mjs.map