@acorex/platform 19.4.15 → 20.0.0-next.0

package/common/index.d.ts

@@ -1,16 +1,1478 @@
-export * from './lib/app';
-export * from './lib/common.module';
-export * from './lib/configs/app.config';
-export * from './lib/configs/config.types';
-export * from './lib/data/index';
-export * from './lib/errors';
-export * from './lib/file-storage';
-export * from './lib/filters';
-export * from './lib/layout';
-export * from './lib/file-storage';
-export * from './lib/file-type';
-export * from './lib/search';
-export * from './lib/settings';
-export * from './lib/utils';
-export * from './lib/workflows';
-export * from './lib/home-page';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnChanges, ElementRef, Renderer2, SimpleChanges, EventEmitter, NgZone, ChangeDetectorRef, EnvironmentProviders, Injector, ErrorHandler, ModuleWithProviders } from '@angular/core';
+import { AXStyleColorType, AXDataSourceOperator, AXDataSourceFilterOption } from '@acorex/cdk/common';
+import * as i2 from '@acorex/components/popup';
+import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
+import { AXPNavigateActionCommand, AXPExecuteCommand, AXPMetaData, AXPValueTransformerFunctions, AXPValidationRules, AXPPlatformScope, AXPPlatformScopeKey, AXPOptionsData, AXPWidgetTriggers, AXPAppStartUpService, AXPLogoConfig, AXPUserReference, AXPApplicationUserReference } from '@acorex/platform/core';
+import { AXPWidgetTypesMap, AXPWidgetNode, AXPMetaDataDefinition } from '@acorex/platform/layout/builder';
+import * as i5 from '@angular/router';
+import { Route, Routes } from '@angular/router';
+import { Subject } from 'rxjs';
+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 _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>;
+
+interface AXPGridLayoutPositions {
+    colStart?: number;
+    colEnd?: number;
+    colSpan?: number;
+    rowStart?: number;
+    rowEnd?: number;
+    rowSpan?: number;
+    order?: string | number;
+}
+interface AXPGridLayoutOptions {
+    positions?: {
+        default?: AXPGridLayoutPositions;
+        md?: AXPGridLayoutPositions;
+        lg?: AXPGridLayoutPositions;
+        xl?: AXPGridLayoutPositions;
+        xxl?: AXPGridLayoutPositions;
+    };
+}
+
+declare class AXPGridLayoutDirective implements OnChanges {
+    private el;
+    private renderer;
+    options: AXPGridLayoutOptions;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnChanges(changes: SimpleChanges): void;
+    private applyTailwindClasses;
+    private setClasses;
+    private clearClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPGridLayoutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPGridLayoutDirective, "[gridLayout]", never, { "options": { "alias": "gridLayout"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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 topOffset;
+    private parentElement;
+    private targetElement;
+    private mutationObserver;
+    stickyParent: string | HTMLElement;
+    stickyTarget: string;
+    constructor(element: ElementRef<HTMLDivElement>, renderer: Renderer2, zone: NgZone, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    private initSticky;
+    private updateTopOffset;
+    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>;
+}
+
+declare class AXPLogoComponent {
+    source: any;
+    protected logoType: string;
+    private platform;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    protected setLogoType(): void;
+    protected setLogoTheme(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPLogoComponent, "axp-logo", never, { "source": { "alias": "source"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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;
+}
+interface AXPMenuFinderResult {
+    insert(items: AXPMenuItem[], position: AXPMenuInsertion): void;
+    remove(): void;
+    update(updatedItem: Partial<AXPMenuItem>): void;
+    addItems(items: AXPMenuItem[]): 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 cache;
+    private pendingInserts;
+    private pendingRemovals;
+    private pendingUpdates;
+    private pendingAdditions;
+    items(): Promise<AXPMenuItem[]>;
+    private createMenuProviderContext;
+    private applyPendingOperations;
+    private findItemWithParent;
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuProviderService>;
+}
+
+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;
+    };
+}>>;
+
+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: AXPCommandActionType;
+    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;
+    search(text: string): Promise<AXPSearchDisplayGroupResult[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSearchService>;
+}
+
+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 AXEntityPropertyWidget {
+    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+    path: string;
+    id?: string;
+    formula?: string;
+    children?: AXEntityPropertyWidget[];
+    mode: 'view' | 'edit' | 'designer';
+    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[];
+}
+interface AXPEntityPropertyView {
+    name: string;
+    dataPath?: string;
+    permissions?: string[];
+    layout?: AXPEntityPropertyLayoutConfig;
+}
+interface AXPEntityPropertyUpdateView extends AXPEntityPropertyView {
+}
+interface AXPEntityPropertyCreateView extends AXPEntityPropertyView {
+    defaultValue?: any;
+}
+interface AXPEntitySectionView {
+    id: string;
+    description?: string;
+    order?: number;
+    layout?: AXPEntityPropertyLayoutConfig;
+}
+interface AXPEntityProperty {
+    name: string;
+    title: string;
+    description?: string;
+    groupId?: string;
+    reference?: {
+        relationId: string;
+    };
+    schema: {
+        dataType: string;
+        nullable?: boolean;
+        readonly?: boolean;
+        hidden?: boolean;
+        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;
+            };
+        };
+        sort?: {
+            enabled?: boolean;
+        };
+    };
+    validations?: AXPValidationRules;
+}
+interface AXPEntityTableColumn {
+    name: string;
+    title?: string;
+    sort?: {
+        enabled?: boolean;
+        dir?: 'asc' | 'desc';
+    };
+    options?: {
+        visible?: boolean;
+        width?: string;
+        dataPath?: string;
+        [name: string]: any;
+    };
+}
+interface AXPEntityCommand {
+    execute: string | Function;
+    permissions?: string[];
+}
+interface AXPEntityQuery {
+    execute: string | Function;
+    type: AXPEntityQueryType;
+}
+type AXPCommandActionType = 'create' | 'update' | 'delete' | 'print' | 'confirm' | 'report' | 'info' | 'view' | 'archive' | 'design' | 'upload' | 'version-history';
+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: AXPCommandActionType;
+    priority: 'primary' | 'secondary';
+    separated?: boolean;
+    permissions?: string[];
+    hidden?: boolean | string;
+    disabled?: boolean | string;
+    default?: boolean;
+}
+interface AXPEntityAction extends AXPCommandActionDisplay {
+    scope: AXPEntityCommandScope;
+}
+interface AXPEntity {
+    module: string;
+    name: string;
+    source: string;
+    parentKey?: string;
+    category?: AXPCategoryEntity;
+    versionHistory?: AXPEntityVersionHistory;
+    title: string;
+    formats: {
+        individual: string;
+        plural: string;
+        lookup?: string;
+        searchResult?: {
+            title: string;
+            description?: string;
+        };
+    };
+    relatedEntities?: AXPRelatedEntity[];
+    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?: AXPQueryFilter[];
+    sorts?: AXPQuerySort[];
+}): AXPQueryView;
+declare function createAllQueryView(params?: {
+    columns?: string[];
+    conditions?: AXPQueryFilter[];
+    sorts?: AXPQuerySort[];
+} | undefined): AXPQueryView;
+interface AXPRelatedEntity {
+    entity: string;
+    title?: string;
+    columns?: string[];
+    conditions?: AXPQueryFilter[];
+    hidden?: boolean | string;
+    actions?: AXPEntityAction[];
+}
+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[];
+}
+interface AXPEntityMasterCreateLayoutView extends AXPEntityMasterLayoutView {
+    steps?: {
+        id: string;
+        title: string;
+        description?: string;
+    };
+}
+interface AXPEntityMasterUpdateLayoutView extends AXPEntityMasterLayoutView {
+}
+interface AXPEntityMasterSingleLayoutView extends AXPEntityMasterLayoutView {
+    title: string;
+    description?: string;
+    actions?: AXPEntityAction[];
+}
+interface AXPEntityMasterListView {
+    title?: string;
+    description?: string;
+    actions?: AXPEntityAction[];
+    views: AXPQueryView[];
+}
+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;
+}
+interface AXPQueryFilter {
+    name: string;
+    operator: AXDataSourceOperator;
+    value: any;
+}
+interface AXPQuerySort {
+    name: string;
+    dir: 'asc' | 'desc';
+}
+declare function resolveActionLook(tr: AXPEntityAction): AXPCommandActionLook;
+
+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 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 AXPSettingValueProvider {
+    get scope(): AXPPlatformScope;
+    load(): Promise<AXPSettingValue[]>;
+    set(key: string, value: any): Promise<void>;
+    set(values: Record<string, any>): Promise<void>;
+}
+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 class AXPSettingDefaultValueProvider implements AXPSettingValueProvider {
+    private definitionProvider;
+    get scope(): AXPPlatformScope;
+    load(): Promise<AXPSettingValue[]>;
+    set(key: string, value: any): Promise<void>;
+    set(values: Record<string, any>): Promise<void>;
+}
+
+declare const AXP_SETTING_VALUE_PROVIDER: InjectionToken<AXPSettingValueProvider[]>;
+
+interface AXPSettingServiceInterface {
+    load(): Promise<AXPSettingValue[]>;
+    get<T = any>(key: string): Promise<T>;
+    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
+    scope(scope: AXPPlatformScope): ScopedSettingService;
+}
+declare class AXPSettingService implements AXPSettingServiceInterface {
+    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<AXPSettingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingService>;
+}
+declare class ScopedSettingService {
+    private parent;
+    private provider;
+    private scopeCache;
+    constructor(parent: AXPSettingService, 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>;
+}
+
+interface AXPCommonModuleConfigs {
+    errorHandlers: (new () => AXPErrorHandler)[];
+}
+declare class AXPCommonModule {
+    static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[], appInitService: AXPAppStartUpService, settingsService: AXPSettingService);
+    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.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 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;
+    /**
+     * Metadata associated with the file.
+     */
+    metadata: AXPMetaData;
+    /**
+     * Indicates whether the file is primary or not.
+     */
+    isPrimary?: boolean;
+}
+/**
+ * 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;
+}
+/**
+ * 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 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>;
+}
+
+type AXPFilterOperation = {
+    type: 'equal' | 'isNull' | 'isEmpty' | 'lt' | 'lte' | 'gt' | 'gte' | 'startsWith' | 'endsWith' | 'contains';
+    negative?: boolean;
+};
+type AXPFilterLogic = 'and' | 'or';
+interface AXPFilterDefinition {
+    title: string;
+    field: string;
+    value?: unknown;
+    isParametric?: boolean;
+    operator: AXPFilterOperation;
+    logic?: AXPFilterLogic;
+    filters?: AXPFilterDefinition[];
+    icon?: string;
+    widget: AXPWidgetNode;
+    filterType: {
+        advance: boolean;
+        inline: boolean;
+    };
+}
+interface AXPFilterQuery extends Pick<AXPFilterDefinition, 'field' | 'value' | 'operator' | 'logic'> {
+    filters?: AXPFilterQuery[];
+}
+
+declare class AXPFiltersProviderService {
+    getAll(): Promise<AXPFilterDefinition[]>;
+    execute(): Promise<AXPFilterQuery[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFiltersProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFiltersProviderService>;
+}
+
+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 AXPClipBoardService {
+    private toast;
+    copy(title: string, value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPClipBoardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPClipBoardService>;
+}
+
+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 {
+    code: string;
+    title: string;
+    timezone?: string;
+}
+interface AXPCity {
+    code: string;
+    title: string;
+    timezone?: string;
+    native: string;
+}
+interface AXPProvince {
+    code: string;
+    title: string;
+    timezone?: string;
+    native: string;
+    cities?: AXPCity[];
+}
+interface AXPCountry extends AXPGeoLocation {
+    timezone: string;
+    regional: string;
+    native: string;
+    provinces?: AXPProvince[];
+}
+interface AXPTimeZone {
+    code: string;
+    title: string;
+    offset: string;
+    iana: string;
+    abbr: string;
+}
+interface AXPCurrency {
+    code: string;
+    title: string;
+    symbol: string;
+    format: string;
+}
+
+declare abstract class AXPRegionalService {
+    abstract getCountries(): Promise<AXPCountry[]>;
+    abstract getProvinces(countryId?: string): Promise<AXPProvince[]>;
+    abstract getCities(filter?: {
+        countryId?: string;
+        provinceId?: string;
+    }): Promise<AXPCity[]>;
+    abstract getCurrencies(): Promise<AXPCurrency[]>;
+    abstract getLocaleProfiles(): Promise<AXPLocaleProfile[]>;
+    abstract getLanguages(): Promise<AXPLanguage[]>;
+    abstract getAvailableLanguages(): Promise<AXPLanguage[]>;
+    abstract getBrowserTimeZoneCode(): Promise<string>;
+    abstract getTimeZones(): Promise<AXPTimeZone[]>;
+}
+
+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 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;
+    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;
+    color: AXStyleColorType;
+    title: string;
+    content: string;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPToastAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPToastAction>;
+}
+
+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>;
+}
+
+interface AXPLockRequest {
+    refId: string;
+    refType: string;
+    type: AXPLockType;
+    date: string;
+    expireAt?: Date;
+    lockedBy: AXPUserReference;
+}
+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>;
+}
+
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPLogoComponent, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalService, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingService, AXPStickyDirective, AXPToastAction, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, createAllQueryView, createQueryView, getEntityInfo, provideDynamicHomePage, resolveActionLook };
+export type { AXEntityPropertyWidget, AXPAggregate, AXPAppVersion, AXPAppVersionProvider, AXPApplication, AXPCategoryEntity, AXPCity, AXPCommandActionCallback, AXPCommandActionDisplay, AXPCommandActionLook, AXPCommandActionPriority, AXPCommandActionType, AXPCommonModuleConfigs, AXPCountry, AXPCurrency, AXPDomToImageOptions, AXPEntity, AXPEntityAction, AXPEntityCommand, AXPEntityDetailListView, AXPEntityMasterCreateLayoutView, AXPEntityMasterLayoutView, AXPEntityMasterListView, AXPEntityMasterSingleLayoutView, AXPEntityMasterUpdateLayoutView, AXPEntityProperty, AXPEntityPropertyCreateView, AXPEntityPropertyGroup, AXPEntityPropertyLayoutConfig, AXPEntityPropertyUpdateView, AXPEntityPropertyView, AXPEntityQuery, AXPEntitySectionView, AXPEntityTableColumn, AXPEntityVersionHistory, AXPErrorHandler, AXPFileExtension, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFileType, AXPFileTypeInfoProvider, AXPFilterDefinition, AXPFilterLogic, AXPFilterOperation, AXPFilterOperator, AXPFilterQuery, AXPGeoLocation, AXPGridLayoutOptions, AXPGridLayoutPositions, AXPGroupSearchResult, AXPHomePageDefinition, AXPLanguage, AXPLocaleProfile, AXPLockGetInfoRequest, AXPLockInfo, AXPLockRequest, AXPLockType, AXPMenuFinderResult, AXPMenuInsertion, AXPMenuItem, AXPMenuItemCommand, AXPMenuItemWithParent, AXPMenuProvider, AXPMenuProviderContext, AXPMenuType, AXPModule, AXPPlatformConfigs, AXPProvince, AXPQueryFilter, AXPQuerySort, AXPQueryView, AXPRelatedEntity, AXPRelationship, AXPRootConfigs, AXPSearchAction, AXPSearchDefinition, AXPSearchDefinitionDisplayFormat, AXPSearchDefinitionProvider, AXPSearchDisplayGroupResult, AXPSearchDisplayResult, AXPSearchDisplayResultForSave, AXPSearchParentResult, AXPSearchProvider, AXPSearchResult, AXPSettingChangedEvent, AXPSettingDefinition, AXPSettingDefinitionGroup, AXPSettingDefinitionProvider, AXPSettingDefinitionSection, AXPSettingServiceInterface, AXPSettingValue, AXPSettingValueProvider, AXPTimeZone, AXPUnLockRequest };