@acorex/platform 0.0.0-ACOREX

package/types/acorex-platform-common.d.ts

@@ -0,0 +1,2926 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Injector, ErrorHandler, ModuleWithProviders, EventEmitter, ElementRef, Renderer2, NgZone, ChangeDetectorRef } from '@angular/core';
+import { AXDataSourceOperator, AXStyleColorType, AXDataSourceFilterOption } from '@acorex/cdk/common';
+import * as i2 from '@acorex/components/popup';
+import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
+import * as i5 from '@acorex/platform/core';
+import { AXPValueTransformerFunctions, AXPOptionsData, AXPExpression, AXPFilterDefinition, AXPMetaData, AXPSystemActionType, AXPValidationRules, AXPGridLayoutOptions, AXPLogoConfig, AXPFileListItem, AXPDataSourceDefinitionProvider, AXPDataSourceDefinition, AXPNavigateActionCommand, AXPExecuteCommand, AXPApplicationUserReference, AXPEntityReference, AXPPlatformScopeKey, AXPPlatformScope, AXPWidgetTriggers, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext } from '@acorex/platform/core';
+import { AXPWidgetTypesMap, AXPMetaDataDefinition, AXPWidgetNode, AXPWidgetProperty } from '@acorex/platform/layout/widget-core';
+import * as i6 from '@angular/router';
+import { Route, Routes } from '@angular/router';
+import * as i1 from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflow } from '@acorex/platform/workflow';
+import * as i3 from '@acorex/core/date-time';
+import * as i4 from '@acorex/components/toast';
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as _ngrx_signals from '@ngrx/signals';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXLocaleProfile } from '@acorex/core/locale';
+
+interface AXPAppVersion {
+    version: string;
+    build: number;
+    date: Date;
+}
+interface AXPAppVersionProvider {
+    provider(): Promise<AXPAppVersion>;
+}
+declare const AXP_APP_VERSION_PROVIDER: InjectionToken<AXPAppVersionProvider>;
+declare class AXPAppVersionService {
+    private provider;
+    getAppVersion(): Promise<AXPAppVersion>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAppVersionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPAppVersionService>;
+}
+
+interface AXEntityPropertyWidget {
+    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+    path?: string;
+    id?: string;
+    children?: AXEntityPropertyWidget[];
+    mode: 'view' | 'edit';
+    options?: Record<string, any>;
+    triggers?: {
+        event: string;
+        action: string;
+        disabled?: boolean;
+    }[];
+    valueTransforms?: AXPValueTransformerFunctions;
+}
+declare enum AXPRelationshipKind {
+    Association = 0,
+    Composition = 1,
+    Aggregation = 2
+}
+declare enum AXPRelationshipCardinality {
+    OneToOne = 0,
+    OneToMany = 1,
+    ManyToMany = 2
+}
+interface AXPRelationship {
+    id: string;
+    from: string;
+    to: string;
+    kind: AXPRelationshipKind;
+    cardinality: AXPRelationshipCardinality;
+}
+declare enum AXPEntityCommandScope {
+    TypeLevel = "typeLevel",
+    Selected = "selected",
+    Individual = "individual",
+    Section = "section"
+}
+declare enum AXPEntityQueryType {
+    Single = "single",
+    List = "list"
+}
+interface AXPEntityPropertyLayoutConfig extends AXPGridLayoutOptions {
+    label?: {
+        visible?: boolean;
+    };
+    order?: number;
+}
+interface AXPEntityPropertyGroup {
+    id: string;
+    title: string;
+    description?: string;
+    permissions?: string[];
+    icon?: string;
+}
+interface AXPEntityPropertyView {
+    name: string;
+    dataPath?: string;
+    permissions?: string[];
+    layout?: AXPEntityPropertyLayoutConfig;
+}
+interface AXPEntityPropertyUpdateView extends AXPEntityPropertyView {
+}
+interface AXPEntityPropertyCreateView extends AXPEntityPropertyView {
+    defaultValue?: any;
+}
+interface AXPEntitySectionView {
+    id: string;
+    order?: number;
+    collapsed?: boolean;
+    layout?: AXPEntityPropertyLayoutConfig;
+}
+interface AXPEntityProperty {
+    name: string;
+    title: string;
+    description?: string;
+    groupId?: string;
+    schema: {
+        dataType: string;
+        nullable?: boolean;
+        readonly?: boolean | string;
+        visible?: boolean | string;
+        defaultValue?: any | string | ((context: any | null) => any);
+        unique?: {
+            enabled: boolean;
+        };
+        interface?: Partial<AXEntityPropertyWidget>;
+    };
+    options?: {
+        filter?: {
+            advance?: {
+                enabled?: boolean;
+                widgetType?: AXPWidgetTypesMap[keyof AXPWidgetTypesMap];
+            };
+            inline?: {
+                enabled?: boolean;
+            };
+            preload?: {
+                enabled?: boolean;
+                required?: boolean;
+            };
+        };
+        sort?: {
+            enabled?: boolean;
+        };
+    };
+    validations?: AXPValidationRules;
+}
+interface AXPEntityTableColumn {
+    name: string;
+    title?: string;
+    hidden?: boolean;
+    showAs?: {
+        type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+        options?: Record<string, any>;
+    };
+    sort?: {
+        enabled?: boolean;
+        dir?: 'asc' | 'desc';
+    };
+    options?: {
+        /** When string, evaluate against parent detail context (e.g. related list). */
+        visible?: boolean | string;
+        width?: string;
+        dataPath?: string;
+        [name: string]: any;
+    };
+}
+interface AXPEntityCommand {
+    execute: string | Function;
+    permissions?: string[];
+}
+interface AXPEntityQuery {
+    execute: string | Function;
+    type: AXPEntityQueryType;
+}
+
+type AXPCommandActionType = AXPSystemActionType;
+interface AXPCommandActionLook {
+    color: AXStyleColorType;
+    icon: string;
+}
+type AXPCommandActionPriority = 'primary' | 'secondary';
+type AXPCommandActionCallback = string | {
+    name: string;
+    options?: {
+        decoration?: {
+            header?: {
+                title?: string;
+            };
+        };
+        process?: {
+            data?: any;
+            [name: string]: any;
+        };
+        layout?: {
+            size?: AXPopupSizeType;
+        };
+        [name: string]: any;
+    };
+    metadata?: AXPMetaData;
+};
+interface AXPCommandActionDisplay extends Partial<AXPCommandActionLook> {
+    name?: string;
+    command: AXPCommandActionCallback;
+    title: string;
+    type: AXPSystemActionType | string;
+    priority: 'primary' | 'secondary';
+    separated?: boolean;
+    permissions?: string[];
+    hidden?: boolean | string;
+    disabled?: boolean | string;
+    default?: boolean;
+    order?: number;
+}
+interface AXPEntityAction extends AXPCommandActionDisplay {
+    scope: AXPEntityCommandScope;
+    /** Child actions for dropdown submenu */
+    items?: AXPEntityAction[];
+}
+interface AXPEntity {
+    plugins?: {
+        name: string;
+        options?: AXPOptionsData;
+    }[];
+    /**
+     * High-level rules: when expression evaluates true, apply actions to the given targets
+     * (property/section/action). Reduces repetition of the same condition across many properties.
+     * Evaluation context: form data, user, entity; precedence vs property-level visible/readonly
+     * must be defined where rules are applied.
+     */
+    rules?: Array<{
+        name: string;
+        expression: AXPExpression;
+        actions: Array<{
+            target: {
+                type: 'property' | 'section' | 'action';
+                name: string;
+            };
+            values: AXPOptionsData;
+        }>;
+    }>;
+    module: string;
+    name: string;
+    icon?: string;
+    parentKey?: string;
+    category?: AXPCategoryEntity;
+    title: string;
+    formats: {
+        individual: string;
+        plural: string;
+        lookup?: string;
+        displayName?: string;
+        searchResult?: {
+            title: string;
+            description?: string;
+        };
+    };
+    relatedEntities?: AXPRelatedEntity[];
+    pages?: AXPEntityPage[];
+    groups?: AXPEntityPropertyGroup[];
+    properties: AXPEntityProperty[];
+    columns?: AXPEntityTableColumn[];
+    commands?: {
+        create?: AXPEntityCommand | undefined;
+        update?: AXPEntityCommand | undefined;
+        delete?: AXPEntityCommand | undefined;
+        [name: string]: AXPEntityCommand | undefined;
+    };
+    queries?: {
+        byKey?: AXPEntityQuery;
+        list?: AXPEntityQuery;
+        lookup?: AXPEntityQuery;
+        history?: AXPEntityQuery;
+        comments?: AXPEntityQuery;
+        [name: string]: AXPEntityQuery | undefined;
+    };
+    validations?: AXPValidationRules;
+    interfaces?: {
+        master?: {
+            single?: AXPEntityMasterSingleLayoutView;
+            list?: AXPEntityMasterListView;
+            create?: AXPEntityMasterCreateLayoutView;
+            update?: AXPEntityMasterUpdateLayoutView;
+        };
+        detail?: {
+            list?: AXPEntityDetailListView;
+        };
+    };
+}
+declare function getEntityInfo(entity: AXPEntity): {
+    source: string;
+    module: {
+        route: string;
+    };
+    entity: {
+        route: string;
+    };
+};
+declare function createQueryView(name: string, title: string, fixed: boolean, params?: {
+    columns?: string[];
+    conditions?: any[];
+    sorts?: AXPQuerySort[];
+}): AXPQueryView;
+declare function createAllQueryView(params?: {
+    columns?: string[];
+    conditions?: AXPQueryFilter[];
+    sorts?: AXPQuerySort[];
+} | undefined): AXPQueryView;
+interface AXPRelatedEntity {
+    entity: string;
+    title?: string;
+    icon?: string;
+    /**
+     * Either a list of property names, or full table column metadata (`AXPEntityTableColumn`).
+     * For table columns, use `options.visible` as boolean or expression string (evaluated on parent detail).
+     */
+    columns?: string[] | AXPEntityTableColumn[];
+    properties?: string[];
+    /** Exclude these properties from the related entity (for merge-detail) */
+    excludeProperties?: string[];
+    layout?: {
+        type: 'tab-detail' | 'tab-list' | 'page-detail' | 'page-list' | 'merge-detail';
+        order?: number;
+        position?: 'before' | 'after' | 'middle';
+    };
+    conditions?: AXPQueryFilter[];
+    /**
+     * Optional toolbar filter definitions merged when the related list is built.
+     * Entries matching an existing property `field` override/extend that filter definition.
+     */
+    customFilterDefinitions?: Partial<AXPFilterDefinition>[];
+    hidden?: boolean | string;
+    actions?: AXPEntityAction[];
+    /**
+     * Relationship-level persistence strategy for merge-detail data.
+     * Defaults:
+     * - strategy: 'embedded'
+     * - idField: last segment of dataPath + 'Id' (or 'relatedId' when dataPath is missing)
+     * - map: undefined (pass-through)
+     * - hydrate: 'eager' (applies to getOne only in mock)
+     * - cascade.delete: 'none'
+     */
+    persistence?: {
+        strategy?: 'embedded' | 'referenced';
+        idField?: string;
+        dataPath?: string;
+        map?: Record<string, string>;
+        hydrate?: 'eager' | 'lazy';
+        cascade?: {
+            delete?: 'none' | 'orphans' | 'all';
+        };
+    };
+}
+interface AXPEntityPage {
+    /**
+     * Key to identify the component in the page component registry
+     */
+    componentKey: string;
+    /**
+     * Property name to render when the page component displays an entity field (e.g. 'questions', 'attachments').
+     * Passed to the page component as pageConfig.field.
+     */
+    field?: string;
+    /**
+     * Title of the page (displayed in navigation)
+     */
+    title?: string;
+    /**
+     * Icon for the page (displayed in navigation)
+     */
+    icon?: string;
+    /**
+     * Description of the page
+     */
+    description?: string;
+    /**
+     * Layout configuration for page positioning
+     */
+    layout?: {
+        /**
+         * Order of the page (lower numbers appear first)
+         */
+        order?: number;
+        /**
+         * Position relative to the main page
+         */
+        position?: 'before' | 'after' | 'middle';
+    };
+    /**
+     * Visibility condition (boolean or expression string)
+     */
+    hidden?: boolean | string;
+    /**
+     * Permissions required to view this page
+     */
+    permissions?: string[];
+    options?: Record<string, any>;
+}
+interface AXPCategoryEntity {
+    entity: string;
+    title?: string;
+    textField?: string;
+    valueField?: string;
+    conditions?: AXPQueryFilter[];
+    applyConditions?: AXPQueryFilter[];
+}
+interface AXPEntityVersionHistory {
+    enabled?: boolean;
+    showInList?: boolean;
+    showInDetail?: boolean;
+}
+interface AXPAggregate {
+    id: string;
+    name: string;
+    title: string;
+    entities: AXPEntity[];
+}
+interface AXPModule {
+    name: string;
+    title: string;
+    aggregates: AXPAggregate[];
+    relationships?: AXPRelationship[];
+}
+interface AXPApplication {
+    name: string;
+    title: string;
+    modules: AXPModule[];
+}
+interface AXPEntityMasterLayoutView {
+    title?: string;
+    sections: AXPEntitySectionView[];
+    properties?: AXPEntityPropertyView[];
+}
+/** Quick create config for lookup widgets (+ button) - uses subset of create form */
+interface AXPEntityQuickCreate {
+    enabled?: boolean;
+    properties?: string[];
+    layout?: {
+        size?: AXPopupSizeType;
+    };
+    excludeProperties?: string[];
+}
+interface AXPEntityMasterCreateLayoutView extends AXPEntityMasterLayoutView {
+    steps?: {
+        id: string;
+        title: string;
+        description?: string;
+    };
+    /** Quick create config for lookup widgets - uses subset of create form */
+    quickCreate?: AXPEntityQuickCreate;
+}
+interface AXPEntityMasterUpdateLayoutView extends AXPEntityMasterLayoutView {
+}
+interface AXPEntityMasterSingleLayoutView extends AXPEntityMasterLayoutView {
+    title: string;
+    description?: string;
+    actions?: AXPEntityAction[];
+}
+interface AXPEntityMasterListView {
+    title?: string;
+    description?: string;
+    actions?: AXPEntityAction[];
+    views: AXPQueryView[];
+    layouts?: {
+        table?: {
+            columns: AXPEntityTableColumn[];
+        };
+        card?: {};
+    };
+}
+interface AXPEntityDetailListView {
+    title?: string;
+    description?: string;
+    columns: AXPEntityTableColumn[];
+    actions?: AXPEntityAction[];
+}
+interface AXPQueryView {
+    name: string;
+    fixed: boolean;
+    title: string;
+    columns: string[];
+    conditions: AXPQueryFilter[];
+    sorts: AXPQuerySort[];
+    indexCol?: boolean;
+    pageSize?: number;
+    visible?: boolean;
+}
+interface AXPQueryFilter {
+    name: string;
+    operator: AXDataSourceOperator;
+    value: any;
+}
+interface AXPQuerySort {
+    name: string;
+    dir: 'asc' | 'desc';
+}
+declare enum AXPEntityType {
+    Entity = 0,
+    AggregateRoot = 1,
+    ValueObject = 2
+}
+interface AXPEntityV2 {
+    version: 2;
+    module: string;
+    aggregate: string;
+    name: string;
+    type: AXPEntityType;
+    icon?: string;
+    title: string;
+    description?: string;
+    plugins?: {
+        name: string;
+        options?: AXPOptionsData;
+    }[];
+    pages?: AXPEntityPage[];
+    groups?: AXPEntityPropertyGroup[];
+    properties: AXPEntityProperty[];
+    formats: {
+        individual: string;
+        plural: string;
+        lookup?: string;
+        displayName?: string;
+        searchResult?: {
+            title: string;
+            description?: string;
+        };
+    };
+    columns?: AXPEntityTableColumn[];
+    validations?: AXPValidationRules;
+    interfaces?: {
+        master?: {
+            single?: AXPEntityMasterSingleLayoutView;
+            list?: AXPEntityMasterListView;
+            create?: AXPEntityMasterCreateLayoutView;
+            update?: AXPEntityMasterUpdateLayoutView;
+        };
+        detail?: {
+            list?: AXPEntityDetailListView;
+        };
+    };
+}
+
+interface AXPFilterOperator {
+    name: string;
+    title: string;
+    hasValue: boolean;
+}
+declare const EQ_OPER: AXPFilterOperator;
+declare const NOT_EQ_OPER: AXPFilterOperator;
+declare const GT_OPER: AXPFilterOperator;
+declare const LT_OPER: AXPFilterOperator;
+declare const GTE_OPER: AXPFilterOperator;
+declare const LTE_OPER: AXPFilterOperator;
+declare const CONTAINS_OPER: AXPFilterOperator;
+declare const NOT_CONTAINS_OPER: AXPFilterOperator;
+declare const IN_OPER: AXPFilterOperator;
+declare const STARTS_WITH_OPER: AXPFilterOperator;
+declare const ENDS_WITH_OPER: AXPFilterOperator;
+declare const IS_EMPTY_OPER: AXPFilterOperator;
+declare const IS_NOT_EMPTY_OPER: AXPFilterOperator;
+declare const BETWEEN_OPER: AXPFilterOperator;
+declare const STRING_OPERATORS: AXPFilterOperator[];
+declare const NUMBER_OPERATORS: AXPFilterOperator[];
+declare const BOOLEAN_OPERATORS: AXPFilterOperator[];
+declare const DATE_OPERATORS: AXPFilterOperator[];
+declare const ALL_DEFAULT_OPERATORS: AXPFilterOperator[];
+
+interface AXPHomePageDefinition {
+    key: string;
+    title: string;
+    route: Route;
+}
+declare const AXP_HOME_PAGES: InjectionToken<AXPHomePageDefinition[]>;
+declare const AXP_HOME_PAGE_DEFAULT_KEY: InjectionToken<string>;
+
+declare function provideDynamicHomePage(): EnvironmentProviders;
+
+declare class AXPHomePageService {
+    private defaultHomePageKey;
+    private userHomePageKey;
+    private candidates;
+    private settingsService;
+    private sessionService;
+    private injector;
+    private originalConfig;
+    private loginPath;
+    private get flatCandidates();
+    constructor();
+    private init;
+    load(): Promise<void>;
+    getRegisteredList(): AXPHomePageDefinition[];
+    getRegisteredRoutes(): Routes;
+    getCurrent(): {
+        path: string;
+        title: string;
+    };
+    private findPath;
+    private buildFullPaths;
+    private refreshRoutes;
+    private applyMergedConfig;
+    navigateTo(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPHomePageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPHomePageService>;
+}
+
+declare class AXPHomePageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPHomePageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPHomePageModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPHomePageModule>;
+}
+
+interface AXPErrorHandler {
+    handleError(error: Error, next: (error: Error) => void): void;
+}
+
+declare class AXPErrorHandlerRegistryService {
+    private injector;
+    private errorHandlers;
+    constructor(injector: Injector);
+    register(...plugins: (new () => AXPErrorHandler)[]): void;
+    get handlers(): AXPErrorHandler[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPErrorHandlerRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPErrorHandlerRegistryService>;
+}
+
+declare class AXPGlobalErrorHandler extends ErrorHandler {
+    private injector;
+    private registry;
+    constructor(injector: Injector, registry: AXPErrorHandlerRegistryService);
+    handleError(error: Error): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPGlobalErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPGlobalErrorHandler>;
+}
+
+interface AXPCommonModuleConfigs {
+    errorHandlers: (new () => AXPErrorHandler)[];
+}
+declare class AXPCommonModule {
+    static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPCommonModule, never, [typeof i1.AXPWorkflowModule, typeof i2.AXPopupModule, typeof i3.AXDateTimeModule, typeof i4.AXToastModule, typeof i5.AXPModuleManifestModule], [typeof i6.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPCommonModule>;
+}
+
+declare const ENVIRONMENT: InjectionToken<any>;
+declare const AXP_PLATFORM_CONFIG_TOKEN: InjectionToken<AXPPlatformConfigs>;
+interface AXPPlatformConfigs {
+    title?: string;
+    copyright?: string;
+    logo?: {
+        icon: {
+            light: AXPLogoConfig;
+            dark: AXPLogoConfig;
+        };
+        text: {
+            light: AXPLogoConfig;
+            dark: AXPLogoConfig;
+        };
+        full: {
+            light: AXPLogoConfig;
+            dark: AXPLogoConfig;
+        };
+    };
+    network?: {
+        timeOut?: number;
+    };
+}
+declare const AXPPlatformDefaultConfigs: AXPPlatformConfigs;
+declare function configPlatform(config?: Partial<AXPPlatformConfigs>): AXPPlatformConfigs;
+
+declare enum AXPCommonSettings {
+    EnableOperationToasts = "Common:Setting:Notifications.EnableOperationToasts",
+    EntityFilterApplyMode = "Common:Setting:Entity.FilterApplyMode",
+    ShowCategoryColumnsByDefault = "Common:Setting:Entity.ShowCategoryColumnsByDefault",
+    ApplyLayoutOrdering = "Common:Setting:Entity.ApplyLayoutOrdering",
+    RedirectToDetailsAfterCreate = "Common:Setting:Entity.RedirectToDetailsAfterCreate",
+    ShowPageBadge = "Common:Setting:Entity.ShowPageBadge",
+    DebugMode = "PlatformDevTools:Setting:Developer.DebugMode"
+}
+
+declare const AXP_ROOT_CONFIG_TOKEN: InjectionToken<AXPRootConfigs>;
+interface AXPRootConfigs {
+    baseUrl: string;
+}
+
+declare abstract class AXPDataProvider {
+    abstract insertOne(entity: any, entityItem: any): Promise<any>;
+    abstract insertMany(entity: any, entityList: any): Promise<any>;
+    abstract getOne(entity: any, id: string): Promise<any>;
+    abstract getMany(entity: any, params?: any): Promise<any>;
+    abstract updateOne(entity: any, id?: string, data?: {
+        [key: string]: any;
+    }): Promise<any>;
+    abstract deleteOne(entity: any, id: string): Promise<any>;
+    abstract getFirst(entity: any): Promise<any>;
+    abstract uploadFile(file: File, title: string, customUrl?: string): Promise<string>;
+    abstract updateFile(id: string, file: File, title: string, customUrl?: string): Promise<string>;
+    abstract uploadMultipleFiles(files: File[], title: string): Promise<string[]>;
+    abstract viewFile(id: string, name: string): Promise<Blob>;
+    abstract downloadFile(id: string, name: string): Promise<Blob>;
+}
+
+declare abstract class AXPFilterOperatorMiddlewareService {
+    /**
+     * Middleware to transform selected filters into corresponding operators.
+     * @param filters Array of selected filters (e.g., user input).
+     * @param customOperators Optional custom operators map to override default operators.
+     * @returns Transformed filters based on custom or default operators.
+     */
+    abstract transformFilters(filters: AXDataSourceFilterOption[]): AXDataSourceFilterOption[];
+    /**
+     * Helper method to transform a single filter. This handles recursion for nested filters.
+     * @param filter A single filter object.
+     * @returns Transformed filter.
+     */
+    abstract transformFilter(filters: AXDataSourceFilterOption): AXDataSourceFilterOption;
+    abstract getOperator(key: string): AXDataSourceOperator;
+}
+declare class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddlewareService {
+    private customOperatorService;
+    private operators;
+    transformFilters(filters: AXDataSourceFilterOption[]): AXDataSourceFilterOption[];
+    transformFilter(filter: AXDataSourceFilterOption): AXDataSourceFilterOption;
+    getOperator(key: string): AXDataSourceOperator;
+    private getDefaultOperators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFilterOperatorMiddlewareServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFilterOperatorMiddlewareServiceImpl>;
+}
+
+declare abstract class AXPCustomOperatorService {
+    abstract getCustomOperators(): {
+        [key: string]: AXDataSourceOperator;
+    };
+}
+declare class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
+    getCustomOperators(): {
+        [key: string]: AXDataSourceOperator;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCustomOperatorServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCustomOperatorServiceImpl>;
+}
+
+declare enum AXPFileStorageStatus {
+    Temporary = "temporary",// File is not yet associated with a parent entity
+    Committed = "committed",// File is fully associated and in use
+    PendingDeletion = "pendingDeletion",// File is marked for deletion but not yet removed
+    Archived = "archived",// File is archived and no longer actively used
+    Error = "error"
+}
+/**
+ * Interface representing a file storage request in the Acorex platform.
+ */
+interface AXPFileStorageCreateRequest {
+    /**
+     * The file to be stored.
+     */
+    file: File;
+    /**
+     * The name of the file.
+     */
+    name?: string;
+    /**
+     * The unique identifier of referenced entity.
+     */
+    refId: string;
+    /**
+     * The type of the referenced entity.
+     */
+    refType: string;
+    /**
+     * The category of the file. profile-picture, company-logo, policy, document, etc.
+     */
+    category: string;
+    /**
+     * The folder path where the file should be stored.
+     * If null, the service will resolve the path based on metadata, user, tenant, or default rules.
+     */
+    path?: string;
+    /**
+     * Metadata associated with the file.
+     */
+    metadata?: AXPMetaData;
+    /**
+     * Indicates whether the file is primary or not.
+     */
+    isPrimary?: boolean;
+    /**
+     * Indicates the status of the file.
+     */
+    status?: AXPFileStorageStatus;
+}
+interface AXPFileStorageUpdateRequest {
+    /**
+     * The unique identifier for the stored file.
+     */
+    fileId: string;
+    /**
+     * The folder path where the file should be stored.
+     * If null, the service will resolve the path based on metadata, user, tenant, or default rules.
+     */
+    path?: string;
+    /**
+     * The name of the file.
+     */
+    name?: string;
+    /**
+     * Metadata associated with the file.
+     */
+    metadata: AXPMetaData;
+    /**
+     * Indicates whether the file is primary or not.
+     */
+    isPrimary?: boolean;
+}
+interface AXPFileManyStorageInfo {
+    /**
+     * The unique identifier for the stored file.
+     */
+    id?: string;
+    /**
+     * The unique identifier for the stored file.
+     */
+    fileId: string;
+    /**
+     * The unique identifier of referenced entity.
+     */
+    refId: string;
+    /**
+     * The type of the referenced entity.
+     */
+    refType: string;
+    /**
+     * The size of the file in bytes.
+     */
+    size: number;
+    /**
+     * The name of the file.
+     */
+    name?: string;
+    /**
+     * The URL where the file can be accessed.
+     */
+    url?: string;
+    /**
+     * Optional title (e.g. for display in file list).
+     */
+    title?: string;
+    /**
+     * Optional description (e.g. for display in file list).
+     */
+    description?: string;
+}
+/**
+ * Represents information about a file stored in the AXP file storage system.
+ */
+interface AXPFileStorageInfo {
+    /**
+     * The unique identifier for the stored file.
+     */
+    id?: string;
+    /**
+     * The unique identifier for the stored file.
+     */
+    fileId: string;
+    /**
+     * The unique identifier of referenced entity.
+     */
+    refId: string;
+    /**
+     * The type of the referenced entity.
+     */
+    refType: string;
+    /**
+     * The category of the file. profile-picture, company-logo, policy, document, etc.
+     */
+    category: string;
+    /**
+     * The URL where the file can be accessed.
+     */
+    url?: string;
+    /**
+     * The size of the file in bytes.
+     */
+    size: number;
+    /**
+     * The name of the file.
+     */
+    name?: string;
+    /**
+     * The MIME type of the file.
+     */
+    mimeType: string;
+    /**
+     * The date and time when the file was uploaded.
+     */
+    uploadedAt: Date;
+    /**
+     * Indicates whether the file is public or private.
+     */
+    isPublic: boolean;
+    /**
+     * Indicates whether the file is primary or not.
+     */
+    isPrimary?: boolean;
+    status: AXPFileStorageStatus;
+    binary: File;
+}
+interface AXPFileStorageInfo {
+    /**
+     * The unique identifier for the stored file.
+     */
+    id?: string;
+    /**
+     * The unique identifier for the stored file.
+     */
+    fileId: string;
+    /**
+     * The unique identifier of referenced entity.
+     */
+    refId: string;
+    /**
+     * The type of the referenced entity.
+     */
+    refType: string;
+    /**
+     * The category of the file. profile-picture, company-logo, policy, document, etc.
+     */
+    category: string;
+    /**
+     * The URL where the file can be accessed.
+     */
+    url?: string;
+    /**
+     * The size of the file in bytes.
+     */
+    size: number;
+    /**
+     * The name of the file.
+     */
+    name?: string;
+    /**
+     * The MIME type of the file.
+     */
+    mimeType: string;
+    /**
+     * The date and time when the file was uploaded.
+     */
+    uploadedAt: Date;
+    /**
+     * Indicates whether the file is public or private.
+     */
+    isPublic: boolean;
+    /**
+     * Indicates whether the file is primary or not.
+     */
+    isPrimary?: boolean;
+    status: AXPFileStorageStatus;
+    binary: File;
+}
+/**
+ * Represents information about a file stored in the AXP file storage system.
+ */
+interface AXPFileStorageFindRequest {
+    /**
+     * The unique identifier of referenced entity.
+     */
+    refId?: string;
+    /**
+     * The type of the referenced entity.
+     */
+    refType?: string;
+    /**
+     * The category of the file. profile-picture, company-logo, policy, document, etc.
+     */
+    category?: string;
+    /**
+     * The MIME type of the file.
+     */
+    mimeType?: string;
+    /**
+     * Indicates whether the file is public or private.
+     */
+    isPublic?: boolean;
+    /**
+     * Indicates whether the file is primary or not.
+     */
+    isPrimary?: boolean;
+    /**
+     * The date and time range when the file was uploaded.
+     */
+    uploadedAtRange?: {
+        from: Date;
+        to: Date;
+    };
+}
+
+declare abstract class AXPFileStorageService {
+    abstract save(request: AXPFileStorageCreateRequest): Promise<AXPFileStorageInfo>;
+    abstract update(request: AXPFileStorageUpdateRequest): Promise<AXPFileStorageInfo>;
+    abstract find(request: AXPFileStorageFindRequest): Promise<AXPFileStorageInfo[]>;
+    abstract findMany(ids: string[]): Promise<AXPFileManyStorageInfo[]>;
+    abstract getInfo(fileId: string): Promise<AXPFileStorageInfo>;
+    abstract remove(fileId: string): Promise<void>;
+    abstract commit(fileId: string): Promise<void>;
+    abstract markForDeletion(fileId: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFileStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFileStorageService>;
+}
+
+/**
+ * Capabilities API provided to file action providers.
+ * These methods allow actions to interact with the file uploader widget.
+ */
+interface AXCFileUploaderCapabilities {
+    /**
+     * Get all current files in the uploader.
+     */
+    getFiles: () => AXPFileListItem[];
+    /**
+     * Replace all files in the uploader.
+     */
+    setFiles: (files: AXPFileListItem[]) => void;
+    /**
+     * Add new files to the uploader.
+     */
+    addFiles: (files: AXPFileListItem[]) => void;
+    /**
+     * Update files matching a predicate.
+     */
+    updateFile: (predicate: (f: AXPFileListItem) => boolean, updater: (f: AXPFileListItem) => AXPFileListItem) => void;
+    /**
+     * Remove a file from the uploader.
+     */
+    removeFile: (file: AXPFileListItem) => void;
+    /**
+     * Clear all files from the uploader.
+     */
+    clear: () => void;
+    /**
+     * Get a file by its ID.
+     */
+    getFileById: (id: string) => AXPFileListItem | undefined;
+    /**
+     * Update a file by its ID.
+     */
+    updateFileById: (id: string, next: Partial<AXPFileListItem>) => void;
+}
+/**
+ * A file uploader action that can be added by providers.
+ */
+interface AXCFileUploaderAction {
+    /**
+     * Unique identifier for the action/plugin.
+     */
+    plugin: string;
+    /**
+     * Whether this action is global (available even if plugin is not explicitly enabled).
+     */
+    global?: boolean;
+    /**
+     * Display text for the action (optional if textKey is provided).
+     */
+    text?: string;
+    /**
+     * Translation key for the action text (optional if text is provided).
+     */
+    textKey?: string;
+    /**
+     * Icon class for the action (e.g., 'fa-light fa-file-arrow-up').
+     */
+    icon?: string;
+    /**
+     * Action execution handler.
+     * Receives capabilities to interact with the file uploader.
+     * @param capabilities The capabilities API for file operations.
+     */
+    run: (capabilities: AXCFileUploaderCapabilities) => void | Promise<void>;
+}
+/**
+ * Payload passed to file action providers.
+ */
+interface AXCFileUploaderActionsPayload {
+    /**
+     * Enabled plugins configuration.
+     */
+    plugins: {
+        name: string;
+        options?: unknown;
+    }[];
+    /**
+     * List of plugin names to exclude.
+     */
+    excludePlugins: string[];
+    /**
+     * Capabilities API for interacting with the file uploader.
+     */
+    capabilities: AXCFileUploaderCapabilities;
+    /**
+     * Current list of actions (providers can add to this array).
+     */
+    actions: AXCFileUploaderAction[];
+    /**
+     * Widget options (optional, for accessing widget-specific settings).
+     */
+    options?: {
+        /**
+         * Whether multiple files are allowed.
+         */
+        multiple?: boolean;
+        /**
+         * Accepted file types (e.g., '.jpg,.png' or 'image/*').
+         */
+        accept?: string;
+    };
+}
+
+/**
+ * Type for file action provider token (supports both direct and async providers).
+ */
+type AXPFileActionProviderToken = AXPFileActionProvider | Promise<AXPFileActionProvider>;
+/**
+ * File action provider interface.
+ * Providers can add actions to the file uploader widget.
+ */
+interface AXPFileActionProvider {
+    /**
+     * Unique key identifying this provider.
+     * Should match the webhook key for backward compatibility: 'file-uploader.actions'
+     */
+    key: string;
+    /**
+     * Execute the provider to add actions.
+     * @param payload The payload containing capabilities and current actions.
+     * @returns The modified payload with new actions added.
+     */
+    execute(payload: AXCFileUploaderActionsPayload): Promise<AXCFileUploaderActionsPayload> | AXCFileUploaderActionsPayload;
+    /**
+     * Priority for execution order (lower numbers execute first).
+     * Defaults to 0 if not specified.
+     */
+    priority?: number;
+}
+/**
+ * Multi-provider injection token for file action providers.
+ * Modules can provide multiple implementations using this token.
+ */
+declare const AXP_FILE_ACTION_PROVIDER: InjectionToken<AXPFileActionProviderToken[]>;
+
+/**
+ * Service for managing file uploader actions.
+ * Aggregates actions from multiple providers and filters them based on plugin configuration.
+ * Wraps the hook system for backward compatibility.
+ */
+declare class AXPFileActionsService {
+    private readonly actionProviders;
+    private readonly hookService;
+    private readonly injector;
+    /**
+     * Get all actions from providers, filtered based on plugin configuration.
+     * Wraps the hook system for backward compatibility.
+     * @param payload Initial payload with capabilities and plugin configuration.
+     * @returns Filtered list of actions.
+     */
+    getActions(payload: AXCFileUploaderActionsPayload): Promise<AXCFileUploaderAction[]>;
+    /**
+     * Resolve all providers (handle both direct providers and Promise<provider>).
+     */
+    private resolveProviders;
+    /**
+     * Filter actions based on enabled plugins and exclude list.
+     */
+    private filterActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFileActionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFileActionsService>;
+}
+
+declare const UploadFromComputerActionProvider: AXPFileActionProvider;
+
+interface AXPFileType {
+    /**
+     * The unique identifier for the file type.
+     */
+    /**
+     * The name unique of the file type.
+     */
+    name: string;
+    /**
+     * The title of the file type.
+     */
+    title: string;
+    /**
+     * The description of the file type.
+     */
+    description?: string;
+    extensions: AXPFileExtension[];
+    /**
+     * The icon of the file type.
+     */
+    icon?: string;
+    /**
+     * The metadata associated with the file type.
+     */
+    meta?: AXPMetaDataDefinition[];
+}
+interface AXPFileExtension {
+    /**
+     * The unique identifier for the file extension.
+     */
+    /**
+     * The name unique of the file extension.
+     */
+    name: string;
+    /**
+     * The title of the file extension.
+     */
+    title: string;
+    /**
+     * The description of the file extension.
+     */
+    description?: string;
+    /**
+    * The icon of the file type.
+    */
+    icon?: string;
+    /**
+     * The color of the file type.
+     */
+    color?: string;
+    /**
+     * The metadata associated with the file extension.
+     */
+    meta?: AXPMetaDataDefinition[];
+}
+
+interface AXPFileTypeInfoProvider {
+    items(): Promise<AXPFileType[]>;
+}
+declare const AXP_FILE_TYPE_INFO_PROVIDER: InjectionToken<AXPFileTypeInfoProvider[]>;
+declare class AXPFileTypeProviderService implements AXPFileTypeInfoProvider {
+    private providers;
+    items(): Promise<AXPFileType[]>;
+    get(name: string): Promise<AXPFileType | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFileTypeProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFileTypeProviderService>;
+}
+
+declare class AXPStickyDirective {
+    private element;
+    private renderer;
+    private zone;
+    private cdr;
+    stickyClass: string;
+    stickyOffset: number;
+    isStickyChange: EventEmitter<boolean>;
+    private _isSticky;
+    get isSticky(): boolean;
+    set isSticky(value: boolean);
+    private parentElement;
+    private targetElement;
+    private mutationObserver;
+    private readonly onWindowResize;
+    stickyParent: string | HTMLElement;
+    stickyTarget: string;
+    constructor(element: ElementRef<HTMLDivElement>, renderer: Renderer2, zone: NgZone, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    private initSticky;
+    private getScrollTop;
+    /**
+     * Toggle stuck styling only while this element is visually pinned (matches `position: sticky; top: 0`).
+     * Scroll-offset thresholds would stay true for every section already passed, so multiple stacked stickies
+     * would all keep `--stuck`; geometry fixes that.
+     */
+    private computeShouldStick;
+    private applyStickyStateFromScrollPosition;
+    private onParentScroll;
+    private toggleStickyClasses;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPStickyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPStickyDirective, "[axpSticky]", ["axpSticky"], { "stickyClass": { "alias": "axpSticky"; "required": false; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; }; "stickyParent": { "alias": "stickyParent"; "required": false; }; "stickyTarget": { "alias": "stickyTarget"; "required": false; }; }, { "isStickyChange": "isStickyChange"; }, never, never, true, never>;
+}
+
+/**
+ * Registered menu items (raw tree flattened) for select widgets via dataSource name {@link MENU_ITEMS_DATASOURCE_NAME}.
+ */
+declare const MENU_ITEMS_DATASOURCE_NAME = "platform-menu-items";
+/**
+ * Data source definition for menu items from {@link AXPMenuProviderService#rawItems}.
+ */
+declare class AXPMenuItemsDataSourceDefinition implements AXPDataSourceDefinitionProvider {
+    private readonly menuProviderService;
+    items(): Promise<AXPDataSourceDefinition[]>;
+}
+
+type AXPMenuInsertion = 'before' | 'after' | 'inside';
+type AXPMenuType = 'menu' | 'group' | 'break';
+type AXPMenuItemCommand = AXPNavigateActionCommand<'modal' | 'router'> | AXPExecuteCommand;
+interface AXPMenuItem {
+    text: string;
+    type?: AXPMenuType;
+    name?: string;
+    description?: string;
+    icon?: string;
+    priority?: number;
+    children?: AXPMenuItem[];
+    path?: string;
+    command?: AXPMenuItemCommand | undefined;
+    badgeKey?: string;
+    data?: any;
+    meta?: AXPMetaData;
+    policy?: {
+        permissions?: string[];
+        features?: string[];
+    };
+}
+interface AXPMenuFinderResult {
+    readonly exists: boolean;
+    insert(items: AXPMenuItem[], position: AXPMenuInsertion): void;
+    remove(): void;
+    update(updatedItem: Partial<AXPMenuItem>): void;
+    addItems(items: AXPMenuItem[]): void;
+    /**
+     * Moves the item matched by the current `find` target to another place in the tree.
+     * @param destination Name of the target menu item (group or item).
+     * @param position `inside` — child of `destination` (default). `before` / `after` — sibling of `destination` in its parent's list.
+     */
+    moveTo(destination: string, position?: AXPMenuInsertion): void;
+}
+interface AXPMenuProviderContext {
+    addItems(items: AXPMenuItem[]): void;
+    find(target: string): AXPMenuFinderResult;
+}
+
+interface AXPMenuProvider {
+    provide(context: AXPMenuProviderContext): Promise<void>;
+}
+declare const AXP_MENU_PROVIDER: InjectionToken<AXPMenuProvider[]>;
+declare class AXPMenuProviderService {
+    private providers;
+    private middlewareRegistry;
+    private cache;
+    private pendingInserts;
+    private pendingRemovals;
+    private pendingUpdates;
+    private pendingAdditions;
+    private pendingMoves;
+    /**
+     * Observable for menu reload events
+     * Emits when menu cache is cleared and consumers should reload
+     */
+    private menuReloadSubject;
+    readonly menuReload$: rxjs.Observable<void>;
+    /**
+     * Get menu items with middlewares applied (for end-user display)
+     */
+    items(): Promise<AXPMenuItem[]>;
+    /**
+     * Get raw menu items WITHOUT middleware applied (for management/editing)
+     * Used by menu management pages to show original items before customization
+     */
+    rawItems(): Promise<AXPMenuItem[]>;
+    /**
+     * Clear the cache to force reload of menu items
+     * Notifies all subscribers to reload their menu data
+     */
+    clearCache(): void;
+    /**
+     * Apply middlewares in priority order using the enhanced context API
+     */
+    private applyMiddlewares;
+    /**
+     * Create provider context for menu providers
+     */
+    private createMenuProviderContext;
+    private applyPendingOperations;
+    private findItemWithParent;
+    /**
+     * Find menu item by name in the items tree (recursive search)
+     */
+    private findItemByName;
+    private applyPendingMove;
+    private itemIsInSubtreeOf;
+    /**
+     * Merge new item properties into existing item, handling children merge
+     */
+    private mergeMenuItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuProviderService>;
+}
+
+/**
+ * Rich context API for manipulating menu items within middleware
+ * Provides helper methods to find, update, remove, and add menu items easily
+ */
+interface AXPMenuMiddlewareContext {
+    /**
+     * Get all menu items
+     */
+    readonly items: AXPMenuItem[];
+    /**
+     * Find menu item(s) by name or pattern
+     */
+    find(nameOrPattern: string | RegExp): AXPMenuItemFinder;
+    /**
+     * Find menu item by name (exact match)
+     */
+    findByName(name: string): AXPMenuItemFinder;
+    /**
+     * Find menu items by pattern (regex or wildcard)
+     */
+    findByPattern(pattern: string | RegExp): AXPMenuItemFinder[];
+    /**
+     * Add new menu items to root level
+     */
+    add(...items: AXPMenuItem[]): AXPMenuMiddlewareContext;
+    /**
+     * Remove menu items by predicate
+     */
+    remove(predicate: (item: AXPMenuItem) => boolean): AXPMenuMiddlewareContext;
+    /**
+     * Sort all menu items recursively by priority
+     */
+    sort(): AXPMenuMiddlewareContext;
+    /**
+     * Get the final menu items array
+     */
+    toArray(): AXPMenuItem[];
+}
+/**
+ * Helper for finding and manipulating a specific menu item
+ */
+interface AXPMenuItemFinder {
+    /**
+     * Get the found menu item (or undefined)
+     */
+    get(): AXPMenuItem | undefined;
+    /**
+     * Check if menu item exists
+     */
+    exists(): boolean;
+    /**
+     * Update menu item properties
+     */
+    update(updater: Partial<AXPMenuItem> | ((item: AXPMenuItem) => Partial<AXPMenuItem>)): AXPMenuItemFinder;
+    /**
+     * Remove the menu item
+     */
+    remove(): AXPMenuItemFinder;
+    /**
+     * Hide the menu item (removes it from the menu)
+     */
+    hide(): AXPMenuItemFinder;
+    /**
+     * Show the menu item (currently a no-op as items are visible by default)
+     * Note: To truly implement show, we'd need to track removed items
+     */
+    show(): AXPMenuItemFinder;
+    /**
+     * Set priority
+     */
+    setPriority(priority: number): AXPMenuItemFinder;
+    /**
+     * Add children to this menu item
+     */
+    addChildren(...children: AXPMenuItem[]): AXPMenuItemFinder;
+    /**
+     * Remove children by predicate
+     */
+    removeChildren(predicate: (child: AXPMenuItem) => boolean): AXPMenuItemFinder;
+    /**
+     * Move menu item to a different parent
+     */
+    moveTo(parentName: string | null | undefined): AXPMenuItemFinder;
+    /**
+     * Insert menu items before this item
+     */
+    insertBefore(...items: AXPMenuItem[]): AXPMenuItemFinder;
+    /**
+     * Insert menu items after this item
+     */
+    insertAfter(...items: AXPMenuItem[]): AXPMenuItemFinder;
+}
+/**
+ * Middleware that processes menu items after all providers have executed
+ * Middlewares are executed in order based on their priority (higher priority = earlier execution)
+ */
+interface AXPMenuMiddleware {
+    /**
+     * Optional priority for execution order (higher = earlier)
+     * Default: 0
+     */
+    readonly priority?: number;
+    /**
+     * Optional name for debugging and identification
+     */
+    readonly name?: string;
+    /**
+     * Process menu items using the rich context API
+     * @param context - The menu middleware context with helper methods
+     * @returns Processed context or void (context is mutable)
+     */
+    process(context: AXPMenuMiddlewareContext): Promise<void | AXPMenuMiddlewareContext>;
+}
+/**
+ * Provider definition for registering middleware via multi-provider
+ */
+interface AXPMenuMiddlewareProvider {
+    /**
+     * The middleware instance
+     */
+    middleware: AXPMenuMiddleware;
+    /**
+     * Optional priority override
+     */
+    priority?: number;
+}
+/**
+ * Injection token for menu middlewares (multi-provider)
+ */
+declare const AXP_MENU_MIDDLEWARE: InjectionToken<AXPMenuMiddleware[]>;
+
+/**
+ * Creates a rich context for menu manipulation
+ * Similar to entity modifier context pattern
+ */
+declare function createMenuContext(items: AXPMenuItem[]): AXPMenuMiddlewareContext;
+
+/**
+ * Central service for managing menu middlewares with priority-based ordering
+ * Similar to token registry pattern used in identifier-management
+ */
+declare class AXPMenuMiddlewareRegistry {
+    /**
+     * Manually registered middlewares
+     */
+    private readonly manualMiddlewares;
+    /**
+     * Provider-based middlewares (multi-provider injection)
+     */
+    private readonly providerMiddlewares;
+    /**
+     * Manually register a middleware
+     * @param middleware - The middleware to register
+     */
+    register(middleware: AXPMenuMiddleware): void;
+    /**
+     * Unregister a middleware by name
+     * @param name - The name of the middleware to remove
+     */
+    unregister(name: string): void;
+    /**
+     * Get a specific middleware by name
+     * @param name - The middleware name
+     */
+    get(name: string): AXPMenuMiddleware | undefined;
+    /**
+     * Get all middlewares sorted by priority (highest first)
+     * Combines provider-based and manually registered middlewares
+     */
+    list(): AXPMenuMiddleware[];
+    /**
+     * Check if a middleware exists
+     * @param name - The middleware name
+     */
+    exists(name: string): boolean;
+    /**
+     * Clear all manually registered middlewares
+     * Provider-based middlewares are not affected
+     */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuMiddlewareRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuMiddlewareRegistry>;
+}
+
+/**
+ * Helper function to provide menu middlewares with proper DI setup
+ * Similar to provideCommandMiddleware pattern
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts or module providers
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideMenuMiddleware([
+ *       customizationMiddleware,
+ *       securityMiddleware,
+ *       loggingMiddleware
+ *     ])
+ *   ]
+ * };
+ * ```
+ */
+declare function provideMenuMiddleware(middlewares: AXPMenuMiddleware[]): EnvironmentProviders;
+/**
+ * Helper to create a class-based middleware with priority
+ *
+ * @example
+ * ```typescript
+ * const myMiddleware = createMenuMiddleware({
+ *   name: 'my-middleware',
+ *   priority: 100,
+ *   process: async (context) => {
+ *     context.find('dashboard').setPriority(1);
+ *   }
+ * });
+ * ```
+ */
+declare function createMenuMiddleware(config: {
+    name: string;
+    priority?: number;
+    process: (context: AXPMenuMiddlewareContext) => Promise<void>;
+}): AXPMenuMiddleware;
+
+declare const AXPMenuService: i0.Type<{
+    items: i0.Signal<AXPMenuItem[]>;
+    selectedMenuItem: _ngrx_signals.DeepSignal<{
+        item: AXPMenuItem | null;
+        isFullMatch: boolean;
+    }>;
+    setMenuItems: (items: AXPMenuItem[]) => void;
+    selectMenuItemByRoute: (path: string) => void;
+    executeCommand: (item: AXPMenuItem) => void;
+    isItemOpen: (item: AXPMenuItem) => boolean;
+} & _ngrx_signals.StateSource<{
+    items: AXPMenuItem[];
+    selectedMenuItem: {
+        item: AXPMenuItem | null;
+        isFullMatch: boolean;
+    };
+}>>;
+
+/**
+ * Service for checking menu item visibility based on permissions, features, and children.
+ * This service helps filter out empty menu items that have no visible children.
+ */
+declare class AXPMenuVisibilityService {
+    private sessionService;
+    /**
+     * Checks if a menu item should be visible based on permissions and features.
+     */
+    isItemVisible(item: AXPMenuItem): boolean;
+    /**
+     * Recursively checks if a menu item has any visible children.
+     * @param item The menu item to check
+     * @param getRouterLink Optional function to check if an item has a router link
+     */
+    hasVisibleChildren(item: AXPMenuItem, getRouterLink?: (item: AXPMenuItem) => unknown): boolean;
+    /**
+     * Determines if a menu item should be rendered.
+     * A menu item should be rendered if:
+     * 1. It has a routerLink, OR
+     * 2. It has visible children, OR
+     * 3. It has a command (for non-router navigation)
+     *
+     * @param item The menu item to check
+     * @param getRouterLink Optional function to check if an item has a router link
+     */
+    shouldRenderMenuItem(item: AXPMenuItem, getRouterLink?: (item: AXPMenuItem) => unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuVisibilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuVisibilityService>;
+}
+
+interface AXPSearchDefinitionDisplayFormat {
+    title?: string;
+    description?: string;
+    icon?: string;
+    id?: string;
+}
+interface AXPSearchDefinition {
+    name: string;
+    title: string;
+    group: string;
+    icon: string;
+    order: number;
+    format: AXPSearchDefinitionDisplayFormat;
+    actions: AXPSearchAction[];
+}
+interface AXPSearchParentResult {
+    title: string;
+    data?: any;
+}
+interface AXPSearchResult {
+    id?: string;
+    group: string;
+    data?: any;
+    title?: string;
+    description?: string;
+    icon?: string;
+    command: AXPExecuteCommand;
+    parent?: AXPSearchParentResult;
+}
+interface AXPSearchDisplayGroupResult {
+    name: string;
+    title: string;
+    order: number;
+    children: AXPSearchDisplayResult[];
+}
+interface AXPSearchDisplayResult {
+    id: string;
+    definitionName?: string;
+    definitionTitle?: string;
+    name: string;
+    title: string;
+    description?: string;
+    icon: string;
+    data?: any;
+    order?: any;
+    command: AXPExecuteCommand;
+    parent?: AXPSearchParentResult;
+    actions: AXPSearchAction[];
+}
+interface AXPSearchDisplayResultForSave {
+    id: string;
+    name: string;
+    title: string;
+    description?: string;
+    icon: string;
+    command: AXPExecuteCommand;
+    parent?: {
+        title: string;
+        description?: string;
+    };
+}
+interface AXPSearchAction extends Partial<AXPCommandActionLook> {
+    name: string;
+    type: AXPSystemActionType | string;
+    priority: AXPCommandActionPriority;
+    separated?: boolean;
+}
+
+declare class AXPSearchDefinitionProviderContext {
+    private definitions;
+    private definitionMap;
+    addDefinition(name: string, title: string, group: string, icon: string, order: number, options?: {
+        format?: AXPSearchDefinitionDisplayFormat;
+        actions?: AXPSearchAction[];
+    }): AXPSearchDefinitionBuilder;
+    getDefinitions(): AXPSearchDefinition[];
+    hasEntity(name: string): boolean;
+    getDefinition(name: string): AXPSearchDefinition | undefined;
+}
+declare class AXPSearchDefinitionBuilder {
+    private context;
+    private definition;
+    constructor(context: AXPSearchDefinitionProviderContext, definition: AXPSearchDefinition);
+    addAction(name: string): AXPSearchDefinitionActionBuilder;
+    action(name: string): AXPSearchDefinitionActionBuilder | null;
+    endEntity(): AXPSearchDefinitionProviderContext;
+}
+declare class AXPSearchDefinitionActionBuilder {
+    private entityBuilder;
+    constructor(entityBuilder: AXPSearchDefinitionBuilder);
+    endAction(): AXPSearchDefinitionBuilder;
+}
+
+interface AXPSearchDefinitionProvider {
+    provide(context: AXPSearchDefinitionProviderContext): Promise<void>;
+}
+declare const AXP_SEARCH_DEFINITION_PROVIDER: InjectionToken<AXPSearchDefinitionProvider[]>;
+declare class AXPSearchDefinitionProviderService {
+    private providers;
+    private cache;
+    private load;
+    getListAsync(): Promise<AXPSearchDefinition[]>;
+    getList(): AXPSearchDefinition[];
+    findDefinition(definitionName: string): AXPSearchDefinition;
+    findDefinitionByGroup(definitionGroup: string): AXPSearchDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSearchDefinitionProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSearchDefinitionProviderService>;
+}
+
+interface AXPSearchProvider {
+    search(text: string): Promise<AXPSearchResult[]>;
+}
+declare abstract class AXPSearchCommandProvider {
+    abstract commands: AXPSearchResult[];
+    search(text: string): Promise<AXPSearchResult[]>;
+}
+
+declare const AXP_SEARCH_PROVIDER: InjectionToken<AXPSearchProvider[]>;
+declare class AXPSearchService {
+    private providers;
+    private definitionService;
+    private formatService;
+    private translationService;
+    search(text: string): Promise<AXPSearchDisplayGroupResult[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSearchService>;
+}
+
+/**
+ * Shared utility for creating Entity:Create command options used in search command providers.
+ * Use with command: { name: 'Entity:Create', options: createEntityCommandOptions(...) }
+ */
+declare function createEntityCommandOptions(entityKey: string, entityInfo: {
+    name: string;
+    module: string;
+    title: string;
+}): Record<string, unknown>;
+/**
+ * Creates a search command for "Create {Entity}" with consistent i18n pattern.
+ * Use titleKey/descriptionKey from module (e.g. @module:entity.permissions.create.title).
+ * Standard: "Create {Entity}" for title, "Create new {entities}" for description.
+ */
+declare function createEntitySearchCommand(config: {
+    id: string;
+    entityKey: string;
+    entityInfo: {
+        name: string;
+        module: string;
+        title: string;
+    };
+    titleKey: string;
+    descriptionKey?: string;
+    icon: string;
+}): AXPSearchResult;
+
+declare class AXPMenuSearchDefinitionProvider implements AXPSearchDefinitionProvider {
+    provide(context: AXPSearchDefinitionProviderContext): Promise<void>;
+}
+
+interface AXPMenuItemWithParent extends AXPMenuItem {
+    parent?: AXPMenuItem;
+}
+declare class AXPMenuSearchProvider implements AXPSearchProvider {
+    menuService: AXPMenuProviderService;
+    translateService: AXTranslationService;
+    search(text: string): Promise<AXPSearchResult[]>;
+    /**
+     * Recursively searches AXPMenuItem and its children for a matching text.
+     *
+     * @param menuItems - The array of AXPMenuItem to search in.
+     * @param searchText - The text to search for (case-insensitive).
+     * @returns An array of AXPMenuItem that match the search text.
+     */
+    private searchMenuItems;
+}
+
+declare class AXPFooterTextSlotComponent {
+    text: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFooterTextSlotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPFooterTextSlotComponent, "ng-component", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPNavBarSlotComponent {
+    items: AXPMenuItem[];
+    protected handleCommand(action?: AXPMenuItemCommand): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPNavBarSlotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPNavBarSlotComponent, "ng-component", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface AXPLockRequest {
+    refId: string;
+    refType: string;
+    type: AXPLockType;
+    date: string;
+    expireAt?: Date;
+    lockedBy: AXPEntityReference;
+}
+interface AXPUnLockRequest {
+    refId: string;
+    refType: string;
+    type: AXPLockType;
+}
+interface AXPLockGetInfoRequest {
+    refId: string;
+    refType: string;
+    type?: AXPLockType;
+}
+type AXPLockType = 'admin' | 'user';
+interface AXPLockInfo {
+    id: string;
+    refId: string;
+    refType: string;
+    type: AXPLockType;
+    date: string;
+    expireAt?: Date;
+    lockedBy: AXPApplicationUserReference;
+}
+
+declare abstract class AXPLockService {
+    abstract lock(request: AXPLockRequest): Promise<AXPLockInfo>;
+    abstract unlock(request: AXPUnLockRequest): Promise<void>;
+    abstract check(request: AXPLockGetInfoRequest): Promise<boolean>;
+    abstract getInfo(request: AXPLockGetInfoRequest): Promise<AXPLockInfo>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPLockService>;
+}
+
+/**
+ * Synchronous access to default multi-language behavior for named entity fields and widget
+ * property bindings. Mirrors {@link AXPLayoutOrderingConfigService}: avoids async in entity
+ * modifiers and startup deadlocks.
+ */
+declare class AXPDefaultMultiLanguageConfigService {
+    private readonly settingsService;
+    private readonly _applyDefault;
+    private syncScheduled;
+    constructor();
+    getApplyDefaultMultiLanguage(): boolean;
+    private syncFromSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDefaultMultiLanguageConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDefaultMultiLanguageConfigService>;
+}
+
+/**
+ * Shared multi-language defaults for entity properties and widget property bindings.
+ *
+ * **Circular dependencies:** use only `import type` for `AXPWidgetProperty` and
+ * `AXPEntityProperty` so this module has no runtime imports from widget-core or application
+ * types — `@acorex/platform/layout/widget-core` does not import `@acorex/platform/common`.
+ */
+
+/**
+ * Widget types that support the multiLanguage option (text / rich text editors).
+ */
+declare const MULTILANGUAGE_CAPABLE_WIDGET_TYPES: Set<string>;
+/**
+ * Common property names / binding path segments that are usually translatable when the feature is
+ * enabled in settings. Explicit `multiLanguage` on the property still wins.
+ */
+declare const DEFAULT_MULTILANGUAGE_FIELD_NAMES: Set<string>;
+declare function shouldApplyDefaultMultiLanguageToEntityProperty(prop: AXPEntityProperty): boolean;
+declare function shouldApplyDefaultMultiLanguageToWidgetProperty(prop: AXPWidgetProperty): boolean;
+/**
+ * Leaf widget nodes in entity `schema.interface` trees (e.g. GridLayout → RichText under `pre` /
+ * `post`) — same path/type rules as {@link shouldApplyDefaultMultiLanguageToWidgetProperty}, without
+ * `schema.dataType` (nodes do not carry entity schema).
+ */
+declare function shouldApplyDefaultMultiLanguageToWidgetNode(node: AXPWidgetNode): boolean;
+/**
+ * When {@link AXPDefaultMultiLanguageConfigService#getApplyDefaultMultiLanguage} is true, sets
+ * `options.multiLanguage` on eligible editor leaves inside an entity property's widget tree
+ * (including nested layouts). Used by entity middleware so object fields (e.g. `pre`, `post`) are
+ * covered, not only top-level string properties.
+ */
+declare function withDefaultMultiLanguageOnWidgetNodeTree(root: AXPWidgetNode | undefined | null, applyDefault: boolean): AXPWidgetNode | undefined | null;
+/**
+ * When {@link AXPDefaultMultiLanguageConfigService#getApplyDefaultMultiLanguage} is true, sets
+ * `schema.interface.options.multiLanguage` for eligible string widget properties (same rules as
+ * entity middleware), unless the property already specifies `multiLanguage`.
+ */
+declare function withDefaultMultiLanguageOnWidgetProperty(prop: AXPWidgetProperty, applyDefault: boolean): AXPWidgetProperty;
+
+interface AXPSettingValueProvider {
+    get scope(): AXPPlatformScope;
+    load(): Promise<AXPSettingValue[]>;
+    set(key: string, value: any): Promise<void>;
+    set(values: Record<string, any>): Promise<void>;
+}
+/**
+ * Provider interface for supplying default setting values from higher layers (e.g., app, mocks, API).
+ * Providers are merged by ascending priority; later providers override earlier values on key conflicts.
+ */
+interface AXPSettingDefaultValuesProvider {
+    /** Merge order; lower numbers are applied first. Default is 0. */
+    priority?: number;
+    /** Returns a flat map of setting key to default value. */
+    provide(): Promise<Record<string, unknown>>;
+}
+interface AXPSettingValue {
+    key: string;
+    value: any;
+}
+interface AXPSettingChangedEvent {
+    scope: AXPPlatformScope;
+    keys: string[];
+    values: Record<string, any>;
+    entries: AXPSettingValue[];
+}
+interface AXPSettingDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    widget: AXPWidgetNode;
+    layout?: AXPGridLayoutOptions;
+    scope: AXPPlatformScopeKey;
+    isRequired?: boolean;
+    isInherited?: boolean;
+    isEncrypted?: boolean;
+    defaultValue?: unknown;
+    value?: unknown;
+}
+interface AXPSettingDefinitionGroup {
+    name: string;
+    title: string;
+    icon?: string;
+    description?: string;
+    groups: AXPSettingDefinitionGroup[];
+    sections: AXPSettingDefinitionSection[];
+}
+interface AXPSettingDefinitionSection {
+    name: string;
+    title: string;
+    description?: string;
+    settings: AXPSettingDefinition[];
+}
+interface AXPGroupSearchResult {
+    breadcrumb: {
+        name: string;
+        title: string;
+        description?: string;
+    }[];
+    sections: AXPSettingDefinitionSection[] | null;
+    groups: AXPSettingDefinitionGroup[] | null;
+}
+
+declare class AXPSettingDefinitionProviderContext {
+    private rootGroups;
+    private groupMap;
+    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
+    group(name: string): AXPSettingDefinitionGroupBuilder | null;
+    getGroups(): AXPSettingDefinitionGroup[];
+    hasGroup(name: string): boolean;
+    getGroup(name: string): AXPSettingDefinitionGroup | undefined;
+}
+declare class AXPSettingDefinitionGroupBuilder {
+    private context;
+    private group;
+    constructor(context: AXPSettingDefinitionProviderContext, group: AXPSettingDefinitionGroup);
+    addSection(name: string, title: string, description?: string): AXPSettingDefinitionSectionBuilder;
+    section(name: string): AXPSettingDefinitionSectionBuilder | null;
+    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
+    endGroup(): AXPSettingDefinitionProviderContext;
+}
+declare class AXPSettingDefinitionSectionBuilder {
+    private groupBuilder;
+    private section;
+    constructor(groupBuilder: AXPSettingDefinitionGroupBuilder, section: AXPSettingDefinitionSection);
+    addSetting(setting: {
+        key: string;
+        title: string;
+        scope: AXPPlatformScopeKey;
+        widget: {
+            type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+            options?: AXPOptionsData;
+            triggers?: AXPWidgetTriggers;
+            layout?: AXPGridLayoutOptions;
+        };
+        description?: string;
+        isRequired?: boolean;
+        isInherited?: boolean;
+        isEncrypted?: boolean;
+        defaultValue?: unknown;
+        valueTransforms?: AXPValueTransformerFunctions;
+        validationRules?: AXPValidationRules;
+    }): this;
+    endSection(): AXPSettingDefinitionGroupBuilder;
+}
+
+interface AXPSettingDefinitionProvider {
+    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
+}
+declare const AXP_SETTING_DEFINITION_PROVIDER: InjectionToken<AXPSettingDefinitionProvider[]>;
+declare class AXPSettingDefinitionProviderService {
+    private providers;
+    private cache;
+    private load;
+    reload(): Promise<void>;
+    getListAsync(scope: AXPPlatformScopeKey): Promise<AXPSettingDefinitionGroup[]>;
+    getList(scope: AXPPlatformScopeKey): AXPSettingDefinitionGroup[];
+    defaultValues(): Promise<Record<string, unknown>>;
+    findGroup(scope: AXPPlatformScopeKey, groupName: string): AXPGroupSearchResult;
+    private searchRecursive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefinitionProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingDefinitionProviderService>;
+}
+declare const AXP_SETTING_DEFAULT_VALUES_PROVIDERS: InjectionToken<AXPSettingDefaultValuesProvider[]>;
+declare class AXPSettingDefaultValuesAggregatorService {
+    private readonly definitionService;
+    private readonly providers;
+    getDefaults(): Promise<Record<string, unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefaultValuesAggregatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingDefaultValuesAggregatorService>;
+}
+
+declare const AXP_SETTING_VALUE_PROVIDER: InjectionToken<AXPSettingValueProvider[]>;
+
+interface AXPSettingsServiceInterface {
+    load(): Promise<AXPSettingValue[]>;
+    get<T = any>(key: string): Promise<T>;
+    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
+    scope(scope: AXPPlatformScope): ScopedSettingService;
+}
+declare class AXPSettingsService implements AXPSettingsServiceInterface {
+    private readonly providers;
+    private readonly injector;
+    private readonly eventService;
+    private readonly sessionService;
+    private readonly scopedSettingsCache;
+    readonly onChanged: Subject<AXPSettingChangedEvent>;
+    readonly onLoaded: Subject<void>;
+    constructor();
+    reload(): Promise<void>;
+    load(): Promise<AXPSettingValue[]>;
+    get<T = any>(key: string): Promise<T>;
+    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
+    scope(scope: AXPPlatformScope): ScopedSettingService;
+    invokeChangeEvent(event: AXPSettingChangedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsService>;
+}
+declare class ScopedSettingService {
+    private parent;
+    private provider;
+    private scopeCache;
+    constructor(parent: AXPSettingsService, provider: AXPSettingValueProvider, scopeCache: Map<string, any>);
+    get<T = any>(key: string): Promise<T>;
+    all(): Promise<any>;
+    defaultValues(): Promise<Record<string, unknown>>;
+    set<T = any>(key: string, value: T): Promise<void>;
+    set<T = any>(values: Record<string, T>): Promise<void>;
+    update<T = any>(key: string, updateFn: (currentValue: T) => T): Promise<void>;
+}
+
+/**
+ * Exposes platform settings in expression strings, e.g.
+ * `{{ settings.get('Common:Setting:Entity.ShowPageBadge') }}`.
+ */
+declare class AXPSettingsEvaluatorScopeProvider implements AXPExpressionEvaluatorScopeProvider {
+    private readonly settingsService;
+    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
+}
+
+/**
+ * Regional and locale-related setting keys used by platform widgets and components.
+ * Most values use the `LocaleManagement:Setting:Regional.*` prefix; definitions live in the locale-management module where applicable.
+ */
+declare enum AXPRegionalSetting {
+    LocaleProfile = "LocaleManagement:Setting:Regional.LocaleProfile",
+    TimeZone = "LocaleManagement:Setting:Regional.TimeZone",
+    Language = "LocaleManagement:Setting:Regional.Language",
+    Country = "LocaleManagement:Setting:Regional.Country",
+    Calendar = "LocaleManagement:Setting:Regional.Calendar",
+    FirstDayOfWeek = "LocaleManagement:Setting:Regional.FirstDayOfWeek",
+    WeekendDays = "LocaleManagement:Setting:Regional.WeekendDays",
+    ShortDate = "LocaleManagement:Setting:Regional.ShortDate",
+    MediumDate = "LocaleManagement:Setting:Regional.MediumDate",
+    LongDate = "LocaleManagement:Setting:Regional.LongDate",
+    ShortTime = "LocaleManagement:Setting:Regional.ShortTime",
+    MediumTime = "LocaleManagement:Setting:Regional.MediumTime",
+    LongTime = "LocaleManagement:Setting:Regional.LongTime",
+    MeasurementUnits = "LocaleManagement:Setting:Regional.MeasurementUnits",
+    TemperatureUnits = "LocaleManagement:Setting:Regional.TemperatureUnits",
+    DistanceUnits = "LocaleManagement:Setting:Regional.DistanceUnits",
+    WeightUnits = "LocaleManagement:Setting:Regional.WeightUnits",
+    VolumeUnits = "LocaleManagement:Setting:Regional.VolumeUnits",
+    SpeedUnits = "LocaleManagement:Setting:Regional.SpeedUnits",
+    AreaUnits = "LocaleManagement:Setting:Regional.AreaUnits",
+    /** Default multi-language behavior for standard text field names; defined in locale-management `AXMRegionalSettingProvider`. */
+    MultiLanguageSupport = "LocaleManagement:Setting:Regional.MultiLanguageSupport"
+}
+
+/**
+ * Status Definition Types
+ * Defines the structure for status definitions and their transitions
+ */
+/**
+ * Status definition with metadata
+ */
+interface AXPStatusDefinition {
+    /**
+     * Unique identifier for the status
+     */
+    name: string;
+    /**
+     * Display title for the status
+     */
+    title: string;
+    /**
+     * Color code or semantic color name for the status
+     */
+    color: string;
+    /**
+     * Optional icon class (e.g., 'fa-light fa-check')
+     */
+    icon?: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Optional order for sorting
+     */
+    order?: number;
+    /**
+     * Whether this is a final status (end state)
+     */
+    isFinal?: boolean;
+    /**
+     * Whether this is an initial status (starting state)
+     */
+    isInitial?: boolean;
+    /**
+     * Whether list views should be automatically generated for this status
+     */
+    generateView?: boolean;
+}
+/**
+ * Status transition definition
+ */
+interface AXPStatusTransition {
+    /**
+     * Source status name
+     */
+    from: string;
+    /**
+     * Target status name
+     */
+    to: string;
+    /**
+     * Optional condition expression to evaluate before allowing transition
+     * Uses expression evaluator syntax (e.g., "{{user.isAdmin}}", "{{item.priority > 5}}")
+     */
+    condition?: string;
+    /**
+     * Optional display title for the transition
+     */
+    title?: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Optional command descriptor to execute for this transition
+     * If not provided, defaults to Entity:UpdateStatus with entity, id, and status
+     */
+    command?: {
+        name: string;
+        options?: Record<string, unknown>;
+    };
+    /**
+     * Whether this transition is automatic (no user action required)
+     */
+    isAutomatic?: boolean;
+    /**
+     * Whether this transition requires approval
+     */
+    requiresApproval?: boolean;
+}
+/**
+ * Abstract class for status providers
+ * Similar to AXPTaskBadgeProvider pattern
+ */
+declare abstract class AXPStatusProvider {
+    /**
+     * Unique key for the status (e.g., 'task-management.status')
+     */
+    abstract readonly key: string;
+    /**
+     * List of available status definitions
+     */
+    abstract readonly statuses: AXPStatusDefinition[];
+    /**
+     * List of allowed transitions between statuses
+     */
+    abstract readonly transitions: AXPStatusTransition[];
+    /**
+     * Optional default status name
+     */
+    abstract readonly defaultStatus?: string;
+}
+
+/**
+ * Injection token for status providers
+ * Use with multi: true to register multiple providers
+ */
+declare const AXP_STATUS_PROVIDERS: InjectionToken<AXPStatusProvider[]>;
+/**
+ * Service for managing status definitions from multiple providers
+ * Similar to AXPTaskBadgeService pattern - no cache, direct access
+ *
+ * @example
+ * ```typescript
+ * // In a module providers array:
+ * {
+ *   provide: AXP_STATUS_PROVIDERS,
+ *   useClass: TaskStatusProvider,
+ *   multi: true,
+ * }
+ *
+ * // Example provider implementation:
+ * export class TaskStatusProvider extends AXPStatusProvider {
+ *   readonly key = 'task-management.status';
+ *   readonly statuses = [
+ *     { name: 'todo', title: 'To Do', color: '#6b7280', icon: 'fa-light fa-circle', isInitial: true },
+ *     { name: 'in-progress', title: 'In Progress', color: '#3b82f6', icon: 'fa-light fa-play' },
+ *     { name: 'done', title: 'Done', color: '#10b981', icon: 'fa-light fa-check-circle', isFinal: true },
+ *   ];
+ *   readonly transitions = [
+ *     { from: 'todo', to: 'in-progress', title: 'Start', condition: '{{user.canEdit}}' },
+ *     { from: 'in-progress', to: 'done', title: 'Complete' },
+ *   ];
+ *   readonly defaultStatus = 'todo';
+ * }
+ *
+ * // Later, get the status:
+ * const status = await statusService.getStatus('task-management.status');
+ * if (status) {
+ *   console.log('Statuses:', status.statuses);
+ *   console.log('Transitions:', status.transitions);
+ * }
+ * ```
+ */
+declare class AXPStatusDefinitionProviderService {
+    private providers;
+    private commandService;
+    private statusMap;
+    private initializationPromise;
+    private isInitialized;
+    /**
+     * Initialize providers (resolve promises if needed)
+     * Called lazily on first access
+     */
+    private initialize;
+    private _doInitialize;
+    /**
+     * Get a status provider by key
+     * Ensures initialization is complete before accessing the status map.
+     *
+     * @param key - Status key (e.g., 'task-management.status')
+     * @returns Promise that resolves to status provider with all statuses and transitions, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const status = await statusService.getStatus('task-management.status');
+     * if (status) {
+     *   console.log('Statuses:', status.statuses);
+     *   console.log('Transitions:', status.transitions);
+     * }
+     * ```
+     */
+    getStatus(key: string): Promise<AXPStatusProvider | undefined>;
+    /**
+     * Execute a status transition workflow action
+     * Uses transition.command if provided, otherwise defaults to Entity:UpdateStatus
+     * Validates the transition is allowed before executing
+     *
+     * @param definitionKey - Status definition key
+     * @param transition - The transition to execute
+     * @param context - Context data for the command (must include entity name and id/ids)
+     * @returns Promise that resolves when the command execution completes
+     *
+     * @example
+     * ```typescript
+     * await statusService.executeTransition(
+     *   'task-management.status',
+     *   { from: 'todo', to: 'in-progress' },
+     *   { entity: 'TaskManagement.Task', id: '123', ...entityData }
+     * );
+     * ```
+     */
+    executeTransition(definitionKey: string, transition: AXPStatusTransition, context: Record<string, any>): Promise<void>;
+    /**
+     * Validate if a transition is allowed
+     * Checks if the transition exists in the provider's transitions list
+     */
+    private isValidTransition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPStatusDefinitionProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPStatusDefinitionProviderService>;
+}
+
+/**
+ * Standard system status types
+ * These are the predefined status values used across the platform
+ */
+declare enum AXPSystemStatusType {
+    Todo = "todo",
+    InProgress = "in-progress",
+    InReview = "in-review",
+    Open = "open",
+    Closed = "closed",
+    Blocked = "blocked",
+    Done = "done",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    PendingReview = "pending-review",
+    Approved = "approved",
+    Published = "published",
+    Archived = "archived",
+    Rejected = "rejected",
+    Active = "active",
+    Inactive = "inactive",
+    Pending = "pending",
+    Completed = "completed",
+    Suspended = "suspended",
+    Failed = "failed",
+    Review = "review",
+    Expired = "expired"
+}
+/**
+ * Standard system status definitions
+ * Provides consistent status definitions across the platform
+ * Uses AXPStatusDefinition interface from status-definition.types.ts
+ */
+declare const AXPSystemStatuses: Readonly<{
+    readonly Open: {
+        readonly name: AXPSystemStatusType.Open;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Closed: {
+        readonly name: AXPSystemStatusType.Closed;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Todo: {
+        readonly name: AXPSystemStatusType.Todo;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly InProgress: {
+        readonly name: AXPSystemStatusType.InProgress;
+        readonly title: string;
+        readonly icon: "fa-light fa-play";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly InReview: {
+        readonly name: AXPSystemStatusType.InReview;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Blocked: {
+        readonly name: AXPSystemStatusType.Blocked;
+        readonly title: string;
+        readonly icon: "fa-light fa-ban";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 4;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Done: {
+        readonly name: AXPSystemStatusType.Done;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Cancelled: {
+        readonly name: AXPSystemStatusType.Cancelled;
+        readonly title: string;
+        readonly icon: "fa-light fa-times-circle";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 6;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Draft: {
+        readonly name: AXPSystemStatusType.Draft;
+        readonly title: string;
+        readonly icon: "fa-light fa-file-pen";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly PendingReview: {
+        readonly name: AXPSystemStatusType.PendingReview;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Approved: {
+        readonly name: AXPSystemStatusType.Approved;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Published: {
+        readonly name: AXPSystemStatusType.Published;
+        readonly title: string;
+        readonly icon: "fa-light fa-globe";
+        readonly color: "primary";
+        readonly description: string;
+        readonly order: 4;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Archived: {
+        readonly name: AXPSystemStatusType.Archived;
+        readonly title: string;
+        readonly icon: "fa-light fa-archive";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Rejected: {
+        readonly name: AXPSystemStatusType.Rejected;
+        readonly title: string;
+        readonly icon: "fa-light fa-times-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 6;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Active: {
+        readonly name: AXPSystemStatusType.Active;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Inactive: {
+        readonly name: AXPSystemStatusType.Inactive;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Pending: {
+        readonly name: AXPSystemStatusType.Pending;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Completed: {
+        readonly name: AXPSystemStatusType.Completed;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Suspended: {
+        readonly name: AXPSystemStatusType.Suspended;
+        readonly title: string;
+        readonly icon: "fa-light fa-pause-circle";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Failed: {
+        readonly name: AXPSystemStatusType.Failed;
+        readonly title: string;
+        readonly icon: "fa-light fa-xmark-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Review: {
+        readonly name: AXPSystemStatusType.Review;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 3;
+    };
+    readonly Expired: {
+        readonly name: AXPSystemStatusType.Expired;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+}>;
+/**
+ * Get system status definition by type
+ * @param type - Status type
+ * @returns System status definition or undefined
+ */
+declare function getSystemStatus(type: AXPSystemStatusType): AXPStatusDefinition;
+/**
+ * Resolves the visual appearance (color and icon) for status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Color and icon for the status
+ */
+declare function resolveStatusLook(statusType: string): {
+    color: AXStyleColorType;
+    icon: string;
+};
+/**
+ * Resolves the complete status information (title, description, icon, color) for a status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Complete status information as AXPStatusDefinition
+ */
+declare function getStatusInfo(statusType: string): AXPStatusDefinition;
+/**
+ * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
+ * @param statusType - Status type
+ * @param overrides - Optional overrides for the status definition
+ * @returns AXPStatusDefinition
+ */
+declare function systemStatusToDefinition(statusType: AXPSystemStatusType, overrides?: Partial<AXPStatusDefinition>): AXPStatusDefinition;
+
+interface AXPTokenDefinition {
+    name: string;
+    execute: () => Promise<any> | any;
+}
+
+type AXPTokenDefinitionProviderToken = AXPTokenDefinitionProvider | Promise<AXPTokenDefinitionProvider>;
+declare const AXP_TOKEN_DEFINITION_PROVIDER: InjectionToken<AXPTokenDefinitionProviderToken[]>;
+interface AXPTokenDefinitionProvider<T = any> {
+    name: string;
+    title: string;
+    description?: string;
+    execute(): Promise<T> | T;
+}
+
+declare class AXPTokenDefinitionService {
+    private readonly definitionProviders;
+    /** Cache for definitions by name. */
+    private definitionsByName;
+    /**
+     * Returns a token definition by its name.
+     * First checks the cache, then queries all providers if not found.
+     * @param name The token name.
+     * @returns The token definition if found, undefined otherwise.
+     */
+    getDefinition(name: string): Promise<AXPTokenDefinition | undefined>;
+    /**
+     * Gets the resolved value of a token by its name.
+     * @param name The token name.
+     * @returns The resolved token value, or undefined if the token is not found.
+     */
+    getValue(name: string): Promise<any>;
+    /** Clears the definitions by name cache. */
+    clearDefinitionsCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTokenDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTokenDefinitionService>;
+}
+
+declare class AXPTokenEvaluatorScopeProvider implements AXPExpressionEvaluatorScopeProvider {
+    protected tokenService: AXPTokenDefinitionService;
+    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
+}
+
+declare class AXPClipBoardService {
+    private toast;
+    copy(title: string, value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPClipBoardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPClipBoardService>;
+}
+
+/**
+ * Service for debugging user access information.
+ * Displays loaded modules, features, and permissions for the current user.
+ */
+declare class AXPDebugService {
+    private readonly sessionService;
+    private readonly manifestRegistry;
+    /**
+     * Display all loaded modules, features, and permissions for the current user.
+     */
+    displayUserAccessInfo(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDebugService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDebugService>;
+}
+
+declare class AXPExportService {
+    popupService: AXPopupService;
+    generateBlobFromElement(element: HTMLElement, blobOptions?: AXPDomToImageOptions): Promise<Blob>;
+    download(blob: Blob, filename: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPExportService>;
+}
+interface AXPDomToImageOptions {
+    popup?: true;
+    filter?: (node: Node) => boolean;
+    bgcolor?: string;
+    width?: number;
+    height?: number;
+    style?: {};
+    quality?: number;
+    imagePlaceholder?: string;
+    cacheBust?: boolean;
+    scale?: number;
+}
+
+declare function AXPCleanNestedFilters(filters: AXDataSourceFilterOption[]): AXDataSourceFilterOption[];
+
+interface AXPLocaleProfile extends AXLocaleProfile {
+    code: string;
+    title: string;
+    nativeTitle: string;
+}
+interface AXPLanguage {
+    code: string;
+    title: string;
+}
+interface AXPGeoLocation {
+    id: string;
+    code: string;
+    title: string;
+    timezone?: string;
+}
+interface AXPTimeZone {
+    code: string;
+    title: string;
+    offset: number;
+    iana: string;
+    abbr: string;
+}
+interface AXPCurrency {
+    code: string;
+    title: string;
+    symbol: string;
+    format: string;
+}
+
+/**
+ * Narrow API for reading app locale profiles and active languages.
+ * Implemented by locale-management; consumed by platform layout without importing the module (avoids circular deps).
+ */
+interface AXPLocaleManagementPort {
+    getLocaleProfiles(): Promise<AXPLocaleProfile[]>;
+    getLanguages(): Promise<AXPLanguage[]>;
+}
+declare const AXP_LOCALE_MANAGEMENT_PORT: InjectionToken<AXPLocaleManagementPort>;
+
+interface AXPVersionStream {
+    id: string;
+    entityType: string;
+    entityId: string;
+    createdAt: string;
+}
+declare enum AXVChangeType {
+    Create = "Create",
+    Update = "Update",
+    Delete = "Delete"
+}
+type CanonicalChangeOp = 'add' | 'remove' | 'replace' | 'rename' | 'metadata';
+interface CanonicalChange {
+    path: string;
+    op: CanonicalChangeOp;
+    oldValue?: unknown;
+    newValue?: unknown;
+    meta?: Record<string, unknown>;
+}
+interface AXPVersionEntry {
+    id: string;
+    streamId: string;
+    versionNumber: number;
+    changeType: AXVChangeType;
+    changedBy: string;
+    changedAt: string;
+    snapshotJson: unknown;
+    patchFromPrevJson: CanonicalChange[];
+    summary?: string;
+    metadataJson?: unknown;
+}
+interface AXPVersionChange {
+    id?: number;
+    versionEntryId: string;
+    path: string;
+    op: CanonicalChangeOp;
+    oldValue?: unknown;
+    newValue?: unknown;
+}
+interface VersionedFileInfo {
+    id: string;
+    name: string;
+    size: number;
+    mime: string;
+    hash: string;
+    url?: string;
+    thumbUrl?: string;
+}
+declare abstract class AXPVersioningService {
+    abstract getStreamIdIfExists(entityType: string, entityId: string): Promise<string | null>;
+    abstract listEntries(streamId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<AXPVersionEntry[]>;
+    abstract getUiFriendlyDiff(streamId: string, v1: number, v2: number): Promise<Array<{
+        badge: string;
+        path: string;
+        summary: string;
+        oldValue?: unknown;
+        newValue?: unknown;
+    }>>;
+}
+
+declare const AXPRedirectEvent: {
+    (payload: {
+        url: string;
+    }): {
+        type: string;
+        payload: {
+            url: string;
+        };
+    };
+    type: string;
+};
+declare const AXPRefreshEvent: {
+    (payload: {
+        entity: string;
+        meta?: any;
+    }): {
+        type: string;
+        payload: {
+            entity: string;
+            meta?: any;
+        };
+    };
+    type: string;
+};
+declare const AXPReloadEvent: {
+    (payload: {
+        entity: string;
+        meta?: any;
+    }): {
+        type: string;
+        payload: {
+            entity: string;
+            meta?: any;
+        };
+    };
+    type: string;
+};
+declare class AXPWorkflowNavigateAction extends AXPWorkflowAction {
+    private router;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowNavigateAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowNavigateAction>;
+}
+declare class AXPDialogConfirmAction extends AXPWorkflowAction {
+    private dialogService;
+    private translationService;
+    title: string;
+    message: string;
+    type: AXStyleColorType;
+    defaultAction: string;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDialogConfirmAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDialogConfirmAction>;
+}
+declare class AXPToastAction extends AXPWorkflowAction {
+    private toastService;
+    private translationService;
+    private settingsService;
+    color: AXStyleColorType;
+    title: string;
+    content: string;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPToastAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPToastAction>;
+}
+declare class AXPReloadAction extends AXPWorkflowAction {
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPReloadAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPReloadAction>;
+}
+
+declare class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
+    private router;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    /**
+     * Parses query parameters from a query string into an object.
+     */
+    private parseQueryParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowRouterNavigateAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowRouterNavigateAction>;
+}
+declare const AXPNavigateWorkflow: AXPWorkflow;
+
+declare class AXMWorkflowErrorHandler implements AXPErrorHandler {
+    private dialog;
+    handleError(error: any, next: (error: any) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMWorkflowErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMWorkflowErrorHandler>;
+}
+
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPEntityType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPMenuItemsDataSourceDefinition, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalSetting, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsEvaluatorScopeProvider, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPStickyDirective, AXPSystemStatusType, AXPSystemStatuses, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_LOCALE_MANAGEMENT_PORT, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TOKEN_DEFINITION_PROVIDER, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, MENU_ITEMS_DATASOURCE_NAME, MULTILANGUAGE_CAPABLE_WIDGET_TYPES, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, configPlatform, createAllQueryView, createEntityCommandOptions, createEntitySearchCommand, createMenuContext, createMenuMiddleware, createQueryView, getEntityInfo, getStatusInfo, getSystemStatus, provideDynamicHomePage, provideMenuMiddleware, resolveStatusLook, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, systemStatusToDefinition, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
+export type { AXCFileUploaderAction, AXCFileUploaderActionsPayload, AXCFileUploaderCapabilities, AXEntityPropertyWidget, AXPAggregate, AXPAppVersion, AXPAppVersionProvider, AXPApplication, AXPCategoryEntity, AXPCommandActionCallback, AXPCommandActionDisplay, AXPCommandActionLook, AXPCommandActionPriority, AXPCommandActionType, AXPCommonModuleConfigs, AXPCurrency, AXPDomToImageOptions, AXPEntity, AXPEntityAction, AXPEntityCommand, AXPEntityDetailListView, AXPEntityMasterCreateLayoutView, AXPEntityMasterLayoutView, AXPEntityMasterListView, AXPEntityMasterSingleLayoutView, AXPEntityMasterUpdateLayoutView, AXPEntityPage, AXPEntityProperty, AXPEntityPropertyCreateView, AXPEntityPropertyGroup, AXPEntityPropertyLayoutConfig, AXPEntityPropertyUpdateView, AXPEntityPropertyView, AXPEntityQuery, AXPEntityQuickCreate, AXPEntitySectionView, AXPEntityTableColumn, AXPEntityV2, AXPEntityVersionHistory, AXPErrorHandler, AXPFileActionProvider, AXPFileActionProviderToken, AXPFileExtension, AXPFileManyStorageInfo, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFileType, AXPFileTypeInfoProvider, AXPFilterOperator, AXPGeoLocation, AXPGroupSearchResult, AXPHomePageDefinition, AXPLanguage, AXPLocaleManagementPort, AXPLocaleProfile, AXPLockGetInfoRequest, AXPLockInfo, AXPLockRequest, AXPLockType, AXPMenuFinderResult, AXPMenuInsertion, AXPMenuItem, AXPMenuItemCommand, AXPMenuItemFinder, AXPMenuItemWithParent, AXPMenuMiddleware, AXPMenuMiddlewareContext, AXPMenuMiddlewareProvider, AXPMenuProvider, AXPMenuProviderContext, AXPMenuType, AXPModule, AXPPlatformConfigs, AXPQueryFilter, AXPQuerySort, AXPQueryView, AXPRelatedEntity, AXPRelationship, AXPRootConfigs, AXPSearchAction, AXPSearchDefinition, AXPSearchDefinitionDisplayFormat, AXPSearchDefinitionProvider, AXPSearchDisplayGroupResult, AXPSearchDisplayResult, AXPSearchDisplayResultForSave, AXPSearchParentResult, AXPSearchProvider, AXPSearchResult, AXPSettingChangedEvent, AXPSettingDefaultValuesProvider, AXPSettingDefinition, AXPSettingDefinitionGroup, AXPSettingDefinitionProvider, AXPSettingDefinitionSection, AXPSettingValue, AXPSettingValueProvider, AXPSettingsServiceInterface, AXPStatusDefinition, AXPStatusTransition, AXPTimeZone, AXPTokenDefinition, AXPTokenDefinitionProvider, AXPTokenDefinitionProviderToken, AXPUnLockRequest, AXPVersionChange, AXPVersionEntry, AXPVersionStream, CanonicalChange, CanonicalChangeOp, VersionedFileInfo };