@acorex/platform 21.0.0-next.8 → 21.0.0-next.83

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

@@ -0,0 +1,3673 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Signal, Injector, ErrorHandler, ModuleWithProviders, EventEmitter, ElementRef, Renderer2, NgZone, ChangeDetectorRef } from '@angular/core';
+import { AXDataSourceOperator, AXStyleColorType, AXDataSourceFilterOption } from '@acorex/cdk/common';
+import * as i3 from '@acorex/components/popup';
+import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
+import * as i1 from '@acorex/platform/core';
+import { AXPValueTransformerFunctions, AXPMultiLanguageString, AXPOptionsData, AXPExpression, AXPFilterDefinition, AXPMetaData, AXPSystemActionType, AXPValidationRules, AXPGridLayoutOptions, AXPUserReference, AXPExecuteCommand, AXPKeyboardShortcutHelpEntry, AXPLogoConfig, AXPFileListItem, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext, AXPDataSourceDefinitionProvider, AXPDataSourceDefinition, AXPNavigateActionCommand, AXPKeyboardShortcut, AXPExpressionEvaluatorScope, AXPExpressionEvaluatorService, AXPApplicationUserReference, AXPEntityReference, AXPPlatformScopeKey, AXPWidgetTriggers, AXPPlatformScope } from '@acorex/platform/core';
+import { AXPWidgetTypesMap, AXPWidgetNode, AXPWidgetProperty } from '@acorex/platform/layout/widget-core';
+import * as i4 from '@acorex/core/date-time';
+import { AXCalendarService } from '@acorex/core/date-time';
+import * as _angular_router from '@angular/router';
+import { Route, Routes, UrlTree, Router, RedirectCommand, ActivatedRouteSnapshot, CanActivateFn, CanDeactivateFn, NavigationExtras } from '@angular/router';
+import * as i2 from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflow } from '@acorex/platform/workflow';
+import * as i5 from '@acorex/components/toast';
+import { AXPFileStorageCreateRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFileStorageFindRequest, AXPFileManyStorageInfo, AXPMetaDataDefinition } from '@acorex/platform/contracts';
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as _ngrx_signals from '@ngrx/signals';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXFormatService } from '@acorex/core/format';
+import { AXLocaleProfile } from '@acorex/core/locale';
+
+/** Platform common datasource registry names. */
+declare const AXPPlatformCommonDataSourceKeys: {
+    readonly MenuItems: "platform-menu-items";
+};
+
+/** JSON data primitive for the specialist final deliverable. */
+type AXPAgentOutputKind = 'string' | 'object' | 'array';
+/** When `kind` is `object`, controls how the parsed value maps into chat transcript segments. */
+type AXPOutputTranscriptSegmentId = 'text' | 'node' | 'followUp' | 'file';
+/**
+ * Minimal JSON-Schema-like object for native provider hints and local validation.
+ */
+interface AXPJsonSchemaLike {
+    type?: 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null';
+    properties?: Record<string, AXPJsonSchemaLike>;
+    items?: AXPJsonSchemaLike | AXPJsonSchemaLike[];
+    required?: string[];
+    enum?: unknown[];
+    additionalProperties?: boolean | AXPJsonSchemaLike;
+    description?: string;
+    [key: string]: unknown;
+}
+/** Provider-native structured output hint (OpenAI `response_format`, Gemini `responseMimeType`). */
+type AXPAgentResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    schema: AXPJsonSchemaLike;
+    name?: string;
+    strict?: boolean;
+};
+/**
+ * Catalog row contract for specialist final output (separate from domain `systemPrompt`).
+ * Field paths align with agent/assist entity `outputContract` JSON.
+ */
+interface AXPAgentOutputContract {
+    kind: AXPAgentOutputKind;
+    /**
+     * When `kind` is `object`: `text` = generic JSON object as text; `node` = inner widget node in chat;
+     * `followUp` = `{"type":"followUp","content":[...]}` envelope.
+     */
+    transcriptSegment?: AXPOutputTranscriptSegmentId;
+    instruction?: string;
+    schemaSummary?: string;
+    schema?: AXPJsonSchemaLike;
+    schemaName?: string;
+    schemaStrict?: boolean;
+    validationCommandName?: string;
+    structuredRetries?: number;
+    providerResponseFormat?: AXPAgentResponseFormat;
+}
+/** Default structured retry count when `structuredRetries` is omitted on structured kinds. */
+declare const AXP_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES = 2;
+/**
+ * Registered preset for an output-contract transcript segment.
+ * Modules register via {@link AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER}.
+ */
+interface AXPOutputContractTranscriptSegmentDefinition {
+    /** Segment id (`text`, `node`, `followUp`). */
+    name: AXPOutputTranscriptSegmentId;
+    /** i18n key or display title for admin UI selects. */
+    title: string;
+    description?: string;
+    /** Contract kinds this segment applies to (defaults to `object` only). */
+    applicableKinds?: AXPAgentOutputKind[];
+    /** Default `outputContract` field values when this segment is chosen. */
+    contract: AXPAgentOutputContract;
+}
+
+type AXPOutputContractTranscriptSegmentProviderToken = AXPOutputContractTranscriptSegmentProvider | Promise<AXPOutputContractTranscriptSegmentProvider>;
+/**
+ * Registers one or more transcript-segment presets for agent/assist `outputContract`.
+ * Use with `multi: true` in module providers.
+ */
+interface AXPOutputContractTranscriptSegmentProvider {
+    provide(): AXPOutputContractTranscriptSegmentDefinition[] | Promise<AXPOutputContractTranscriptSegmentDefinition[]>;
+}
+declare const AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER: InjectionToken<AXPOutputContractTranscriptSegmentProviderToken[]>;
+
+declare class AXPOutputContractTranscriptSegmentService {
+    private readonly segmentProviders;
+    private definitionsByName;
+    private loadPromise;
+    /** All registered transcript segment definitions (deduped by `name`). */
+    getAll(): Promise<AXPOutputContractTranscriptSegmentDefinition[]>;
+    /** Lookup by segment id (`text`, `node`, `followUp`). */
+    get(name: AXPOutputTranscriptSegmentId): Promise<AXPOutputContractTranscriptSegmentDefinition | undefined>;
+    /** Default `outputContract` for a segment, or `undefined` when not registered. */
+    getContractPreset(name: AXPOutputTranscriptSegmentId): Promise<AXPAgentOutputContract | undefined>;
+    /** Clears the in-memory registry (e.g. after hot reload in dev). */
+    clearCache(): void;
+    private ensureLoaded;
+    private loadDefinitions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPOutputContractTranscriptSegmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPOutputContractTranscriptSegmentService>;
+}
+
+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;
+    visible?: boolean | AXPExpression;
+}
+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;
+}
+/** Logical alignment for table column header/cell (respects RTL). */
+type AXPColumnContentAlign = 'start' | 'center' | 'end';
+/**
+ * Column alignment: shorthand applies to both header and cell;
+ * object form sets each side independently (omitted keys default to start).
+ */
+type AXPColumnAlign = AXPColumnContentAlign | {
+    header?: AXPColumnContentAlign;
+    cell?: AXPColumnContentAlign;
+};
+/** Shared field definition for list layouts (table columns, card fields, etc.). */
+interface AXPEntityDisplayField {
+    name: string;
+    title?: string;
+    showAs?: {
+        type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+        options?: Record<string, any>;
+    };
+    options?: {
+        /** When string, evaluate against parent detail context (e.g. related list). */
+        visible?: boolean | string;
+        /** Optional dataPath override for field binding. */
+        dataPath?: string;
+        [name: string]: any;
+    };
+}
+/** Card layout field presentation in master list card view. */
+type AXPCardFieldDisplay = 'simple' | 'badge';
+/** Badge color: semantic token or per-row expression (`{{ context.eval(...) }}`). */
+type AXPCardBadgeColor = AXStyleColorType | AXPExpression;
+interface AXPCardBadgeDisplayOptions {
+    /** Semantic color or expression evaluated against row context. */
+    color?: AXPCardBadgeColor;
+}
+interface AXPCardBadgeDisplay {
+    type: 'badge';
+    options?: AXPCardBadgeDisplayOptions;
+}
+/** Shorthand (`badge` / `simple`) or structured badge config with optional per-row color. */
+type AXPCardFieldDisplayConfig = AXPCardFieldDisplay | AXPCardBadgeDisplay;
+/** Card layout field in master list view. */
+type AXPCardField = AXPEntityDisplayField & {
+    layout?: AXPEntityPropertyLayoutConfig;
+    /**
+     * Field presentation. Default: `simple` (card body).
+     * Use `badge` or `{ type: 'badge', options: { color } }` for header chips beside title.
+     */
+    display?: AXPCardFieldDisplayConfig;
+    /**
+     * Badge color when presentation is badge-shaped.
+     * Prefer `display: { type: 'badge', options: { color } }` for new definitions.
+     * Omit for status fields — color is resolved from the status definition per row.
+     */
+    badgeColor?: AXPCardBadgeColor;
+};
+/** Whether the card field is shown as a header badge (not in the card body). */
+declare function isCardFieldBadgeDisplay(display: AXPCardFieldDisplayConfig | undefined): display is 'badge' | AXPCardBadgeDisplay;
+/** Resolves static badge color config from {@link AXPCardField.display} and legacy {@link AXPCardField.badgeColor}. */
+declare function resolveCardFieldBadgeColor(field: Pick<AXPCardField, 'display' | 'badgeColor'>): AXPCardBadgeColor | undefined;
+interface AXPEntityTableColumn extends AXPEntityDisplayField {
+    options?: AXPEntityDisplayField['options'] & {
+        /** Initial column width (overrides widget column width when set). */
+        width?: string;
+        /** Header/cell alignment (shorthand or per-side). */
+        align?: AXPColumnAlign;
+    };
+}
+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' | 'none';
+    separated?: boolean;
+    permissions?: string[];
+    hidden?: boolean | string;
+    disabled?: boolean | string;
+    default?: boolean;
+    order?: number;
+    /**
+     * Keyboard chords for this action (e.g. `'ctrl+shift+a'`).
+     * Pass `[]` to disable shortcuts. When omitted, platform defaults may apply for known commands.
+     */
+    shortcuts?: string[];
+}
+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;
+    columns?: string[] | AXPEntityTableColumn[];
+    properties?: string[];
+    excludeProperties?: string[];
+    layout?: {
+        type: 'tab-detail' | 'tab-list' | 'page-detail' | 'page-list' | 'merge-detail';
+        order?: number;
+        position?: 'before' | 'after' | 'middle';
+    };
+    conditions?: AXPQueryFilter[];
+    customFilterDefinitions?: Partial<AXPFilterDefinition>[];
+    hidden?: boolean | AXPExpression;
+    actions?: AXPEntityAction[];
+    /**
+     * Controls inclusion on the host entity master **create** / **update** form.
+     * Defaults depend on layout:
+     * - **merge-detail**: omitted flags behave as **true** (opt-out with `false`).
+     * - **tab-list** / **page-list**: omitted flags behave as **false** (opt-in with `true`).
+     */
+    appearOn?: {
+        /** Include on host create form (see defaults above per layout type). */
+        create?: boolean;
+        /** Include on host update form (see defaults above per layout type). */
+        update?: boolean;
+    };
+    /**
+     * 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';
+        };
+        foreignKeyField?: string;
+    };
+}
+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?: AXPMultiLanguageString;
+    /**
+     * Icon for the page (displayed in navigation)
+     */
+    icon?: string;
+    /**
+     * Description of the page
+     */
+    description?: AXPMultiLanguageString;
+    /**
+     * 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[];
+    /**
+     * Controls inclusion on the host entity master **create** / **update** form wizard.
+     * Omitted flags behave as **false** (opt-in with `true`), same as `tab-list` / `page-list` related entities.
+     */
+    appearOn?: {
+        /** Include as a wizard step on host create form. */
+        create?: boolean;
+        /** Include as a wizard step on host update form. */
+        update?: boolean;
+    };
+    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: AXPMultiLanguageString;
+    entities: AXPEntity[];
+}
+interface AXPModule {
+    name: string;
+    title: AXPMultiLanguageString;
+    aggregates: AXPAggregate[];
+    relationships?: AXPRelationship[];
+}
+interface AXPApplication {
+    name: string;
+    title: AXPMultiLanguageString;
+    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?: {
+            enabled?: boolean;
+            columns: AXPEntityTableColumn[];
+        };
+        card?: {
+            enabled?: boolean;
+            header: {
+                /** Property path, expression (`{{ ... }}`), or literal — evaluated per row. */
+                title?: string;
+                description?: string;
+                icon?: string;
+            };
+            fields: AXPCardField[];
+        };
+    };
+}
+type AXPEntityMasterListLayoutType = 'table' | 'card';
+/** Master list presentation: table or card with compact (collapsed) / expanded bodies. */
+type AXPEntityMasterListDisplayMode = 'table' | 'card-compact' | 'card-expanded';
+interface AXPEntityMasterListLayoutOption {
+    id: AXPEntityMasterListLayoutType;
+    title: string;
+    icon?: string;
+}
+/** Resolves master list layouts that are currently enabled. */
+declare function resolveEnabledMasterListLayouts(layouts?: AXPEntityMasterListView['layouts']): AXPEntityMasterListLayoutType[];
+/** First enabled layout; used as the default when no user preference is stored. */
+declare function resolveDefaultMasterListLayout(layouts?: AXPEntityMasterListView['layouts']): AXPEntityMasterListLayoutType;
+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[];
+
+type AXPDateTimeFilterPresetKind = 'computed' | 'manual';
+interface AXPDateTimeFilterPreset {
+    id: string;
+    title: string;
+    kind: AXPDateTimeFilterPresetKind;
+    operationType?: string;
+}
+declare const DEFAULT_DATE_FILTER_PRESETS: AXPDateTimeFilterPreset[];
+interface AXPDateTimeFilterValue {
+    operation?: {
+        type: string;
+    };
+    value?: string | {
+        from?: string;
+        to?: string;
+    };
+}
+declare function resolveDateFilterPresets(customPresets?: AXPDateTimeFilterPreset[], presetIds?: string[]): AXPDateTimeFilterPreset[];
+declare function applyDateFilterPreset(presetId: string, calendarService: AXCalendarService): AXPDateTimeFilterValue | undefined;
+declare function findManualPresetIdByOperation(operationType: string | undefined, presets: AXPDateTimeFilterPreset[]): string | undefined;
+
+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;
+    /**
+     * Resolves the current user's home page as a router URL tree.
+     */
+    resolveHomeUrlTree(): UrlTree;
+    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>;
+}
+
+type AXPInAppNotificationPriority = 'Notice' | 'Danger' | 'Warning';
+interface AXPInAppNotificationCreateRequest {
+    id: string;
+    name: string;
+    title: string;
+    body: string;
+    icon: string;
+    priority: AXPInAppNotificationPriority;
+    receiver: AXPUserReference;
+    data?: Record<string, unknown>;
+}
+/**
+ * Persists in-app notifications. Notification-management registers an implementation
+ * backed by {@link AXMNotificationService}.
+ */
+interface AXPInAppNotificationService {
+    create(request: AXPInAppNotificationCreateRequest): Promise<void>;
+}
+declare const AXP_IN_APP_NOTIFICATION_SERVICE: InjectionToken<AXPInAppNotificationService>;
+
+type AXPBackgroundOperationStatus = 'queued' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface AXPBackgroundOperationCapabilities {
+    cancellable: boolean;
+    pausable: boolean;
+    resumable: boolean;
+    retryable: boolean;
+    /** When true, UI shows a progress bar only while {@link AXPBackgroundOperation.progress} is set. */
+    supportsProgress: boolean;
+    /** When true, UI may show ETA while {@link AXPBackgroundOperation.estimatedDurationMs} is set. */
+    supportsEstimate: boolean;
+    /** When true, the tray item is clickable and delegates to a registered handler. */
+    clickable: boolean;
+    /** When false, skip in-app notification on completed/cancelled. Default: true. */
+    notifyOnComplete?: boolean;
+    /** When false, skip in-app notification on failed. Default: true. */
+    notifyOnFailed?: boolean;
+}
+type AXPBackgroundOperationFailureMode = 'retry' | 'continue' | 'abort';
+interface AXPBackgroundOperationFailurePolicy {
+    mode: AXPBackgroundOperationFailureMode;
+    currentStepId?: string;
+    maxRetries?: number;
+    retryCount?: number;
+}
+interface AXPBackgroundOperationError {
+    code?: string;
+    message: string;
+    detail?: string;
+}
+interface AXPBackgroundOperation {
+    id: string;
+    providerKey: string;
+    title: string;
+    status: AXPBackgroundOperationStatus;
+    progress?: number;
+    estimatedDurationMs?: number;
+    statusText?: string;
+    currentStep?: string;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    capabilities: AXPBackgroundOperationCapabilities;
+    failurePolicy: AXPBackgroundOperationFailurePolicy;
+    error?: AXPBackgroundOperationError;
+    /** Handler-specific payload (e.g. conversationId for chat navigation). */
+    data?: Record<string, unknown>;
+}
+interface AXPBackgroundOperationCreateRequest {
+    title: string;
+    progress?: number;
+    estimatedDurationMs?: number;
+    statusText?: string;
+    currentStep?: string;
+    capabilities: AXPBackgroundOperationCapabilities;
+    failurePolicy: AXPBackgroundOperationFailurePolicy;
+}
+type AXPBackgroundOperationActionKey = 'cancel' | 'pause' | 'resume' | 'retry' | 'dismiss';
+
+/**
+ * Sends in-app notifications when a background operation finishes or fails.
+ */
+declare class AXPBackgroundOperationNotificationService {
+    private readonly inAppNotificationService;
+    private readonly sessionService;
+    notify(operation: AXPBackgroundOperation): Promise<void>;
+    private shouldNotify;
+    private resolveBody;
+    private resolveTemplate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBackgroundOperationNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPBackgroundOperationNotificationService>;
+}
+
+/**
+ * Sends notifications and removes tray rows when a background operation reaches a terminal state.
+ */
+declare class AXPBackgroundOperationCompletionService {
+    private readonly notificationService;
+    /** Whether the operation just reached a finished state (completed or cancelled). */
+    shouldAutoFinish(previousStatus: string | undefined, operation: AXPBackgroundOperation): boolean;
+    /** Whether the operation just transitioned to failed. */
+    shouldNotifyFailure(previousStatus: string | undefined, operation: AXPBackgroundOperation): boolean;
+    /** Notifies the user and invokes {@link remove} to drop the operation from the tray. */
+    notifyAndRemove(operation: AXPBackgroundOperation, remove: () => void): Promise<void>;
+    /** Notifies the user while keeping the failed operation in the tray for retry. */
+    notifyFailure(operation: AXPBackgroundOperation): Promise<void>;
+    private notify;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBackgroundOperationCompletionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPBackgroundOperationCompletionService>;
+}
+
+declare const AXPBackgroundOperationRootConfig: {
+    readonly module: {
+        readonly name: "Common";
+        readonly title: "@general:module.common.title";
+        readonly icon: "fa-light fa-layer-group";
+    };
+    readonly entities: {
+        readonly backgroundOperation: {
+            readonly name: "BackgroundOperations";
+            readonly title: "@general:background-operation.entity.title";
+            readonly titlePlural: "@general:background-operation.entity.plural";
+            readonly icon: "fa-light fa-spinner";
+        };
+    };
+};
+/** Full entity key used with {@link AXPEntityStorageService} (e.g. `Common.BackgroundOperations`). */
+declare function axpBackgroundOperationEntityName(): string;
+
+/** Persisted row shape for {@link axpBackgroundOperationEntityName}. */
+interface AXPBackgroundOperationEntityModel {
+    id: string;
+    providerKey: string;
+    title: string;
+    status: AXPBackgroundOperationStatus;
+    progress?: number;
+    estimatedDurationMs?: number;
+    statusText?: string;
+    currentStep?: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    capabilities: AXPBackgroundOperationCapabilities;
+    failurePolicy: AXPBackgroundOperationFailurePolicy;
+    error?: AXPBackgroundOperationError;
+    data?: Record<string, unknown>;
+}
+
+/**
+ * Optional persistence adapter for background-operation entity rows.
+ * Mock connectivity registers an implementation backed by {@link AXPEntityStorageService}.
+ */
+interface AXPBackgroundOperationEntityStorageAdapter {
+    getAll(entityName: string): Promise<AXPBackgroundOperationEntityModel[]>;
+    upsertOne(entityName: string, row: AXPBackgroundOperationEntityModel): Promise<void>;
+    deleteOne(entityName: string, id: string): Promise<void>;
+}
+declare const AXP_BACKGROUND_OPERATION_ENTITY_STORAGE: InjectionToken<AXPBackgroundOperationEntityStorageAdapter>;
+
+declare function axpBackgroundOperationToEntityModel(operation: AXPBackgroundOperation): AXPBackgroundOperationEntityModel;
+declare function axpBackgroundOperationFromEntityModel(model: AXPBackgroundOperationEntityModel): AXPBackgroundOperation;
+
+interface AXPBackgroundOperationProviderStore {
+    readonly operations: Signal<readonly AXPBackgroundOperation[]>;
+    upsert(operation: AXPBackgroundOperation): void;
+    patch(operationId: string, patch: Partial<AXPBackgroundOperation>): void;
+    find(operationId: string): AXPBackgroundOperation | undefined;
+    remove(id: string): void;
+}
+/**
+ * Entity-backed store for background operations (`Common.BackgroundOperations`).
+ * Uses in-memory signals for UI reactivity and optionally persists via {@link AXP_BACKGROUND_OPERATION_ENTITY_STORAGE}.
+ */
+declare class AXPBackgroundOperationEntityStoreService {
+    private readonly entityStorage;
+    private readonly completionService;
+    private readonly entityName;
+    private hydrated;
+    private hydratePromise?;
+    private readonly innerStores;
+    ensureHydrated(): Promise<void>;
+    hasAnyOperationForProviders(providerKeys: readonly string[]): Promise<boolean>;
+    createProviderStore(providerKey: string): AXPBackgroundOperationProviderStore;
+    /** All operations across providers (post-hydration). */
+    readonly allOperations: Signal<AXPBackgroundOperation[]>;
+    private hydrateFromEntityStorage;
+    private persistOperation;
+    private deleteOperation;
+    private getOrCreateInnerStore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBackgroundOperationEntityStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPBackgroundOperationEntityStoreService>;
+}
+
+/**
+ * Storage-only entity for background-operation tray rows (`Common.BackgroundOperations`).
+ * No master UI — persisted through {@link AXPEntityStorageService}.
+ */
+declare function backgroundOperationEntityFactory(): Promise<AXPEntity | null>;
+
+declare const AXP_BACKGROUND_OPERATION_HANDLERS: InjectionToken<AXPBackgroundOperationHandler[]>;
+/**
+ * Handles user interactions for background operations (e.g. navigate on click).
+ * Register one handler per {@link AXPBackgroundOperation.providerKey}.
+ */
+declare abstract class AXPBackgroundOperationHandler {
+    abstract readonly providerKey: string;
+    abstract execute(command: AXPExecuteCommand, operation: AXPBackgroundOperation): Promise<void>;
+}
+
+declare const AXP_BACKGROUND_OPERATION_PROVIDERS: InjectionToken<AXPBackgroundOperationProvider[]>;
+/**
+ * Registers a source of background operations (multi-provider).
+ * Each feature module or mock can contribute one provider per domain key.
+ */
+declare abstract class AXPBackgroundOperationProvider {
+    abstract readonly key: string;
+    abstract readonly operations: Signal<readonly AXPBackgroundOperation[]>;
+    abstract create(request: AXPBackgroundOperationCreateRequest): Promise<AXPBackgroundOperation>;
+    abstract cancel(operationId: string): Promise<void>;
+    /** Optional — only when {@link AXPBackgroundOperationCapabilities.pausable} is true. */
+    pause?(operationId: string): Promise<void>;
+    /** Optional — only when {@link AXPBackgroundOperationCapabilities.resumable} is true. */
+    resume?(operationId: string): Promise<void>;
+    /** Optional — only when {@link AXPBackgroundOperationCapabilities.retryable} is true. */
+    retry?(operationId: string): Promise<void>;
+    /** Optional — removes completed/failed operations from the tray. */
+    dismiss?(operationId: string): Promise<void>;
+}
+
+/**
+ * Lightweight in-memory store for a single background-operation provider.
+ */
+declare function createBackgroundOperationStore(): {
+    readonly operations: Signal<readonly AXPBackgroundOperation[]>;
+    upsert(operation: AXPBackgroundOperation): void;
+    patch(id: string, patch: Partial<AXPBackgroundOperation>): void;
+    find(id: string): AXPBackgroundOperation | undefined;
+    remove(id: string): void;
+};
+
+declare function axpCreateBackgroundOperationId(): string;
+declare function axpBuildBackgroundOperation(providerKey: string, request: AXPBackgroundOperationCreateRequest, overrides?: Partial<AXPBackgroundOperation>): AXPBackgroundOperation;
+declare function axpCoerceBackgroundOperationDate(value: Date | string | undefined): Date | null;
+declare function axpBackgroundOperationDisplayTime(operation: AXPBackgroundOperation): Date | null;
+/**
+ * Remaining duration in milliseconds for ETA display.
+ */
+declare function axpBackgroundOperationRemainingMs(operation: AXPBackgroundOperation): number | null;
+/**
+ * Estimated completion instant for relative-time formatting (e.g. timeleft pipe).
+ */
+declare function axpBackgroundOperationEstimateEndDate(operation: AXPBackgroundOperation): Date | null;
+declare function axpBackgroundOperationCapabilities(partial?: Partial<AXPBackgroundOperationCapabilities>): AXPBackgroundOperationCapabilities;
+declare function axpBackgroundOperationFailurePolicy(partial?: Partial<AXPBackgroundOperationFailurePolicy>): AXPBackgroundOperationFailurePolicy;
+declare function axpIsActiveBackgroundOperationStatus(status: AXPBackgroundOperationStatus): boolean;
+declare function axpIsCompletedBackgroundOperationStatus(status: AXPBackgroundOperationStatus): boolean;
+
+declare class AXPBackgroundOperationService {
+    private readonly providers;
+    private readonly handlers;
+    private readonly busy;
+    readonly loading: i0.Signal<boolean>;
+    readonly operations: i0.Signal<readonly AXPBackgroundOperation[]>;
+    readonly activeCount: i0.Signal<number>;
+    readonly failedCount: i0.Signal<number>;
+    getAvailableActions(operation: AXPBackgroundOperation): AXPBackgroundOperationActionKey[];
+    create(providerKey: string, request: AXPBackgroundOperationCreateRequest): Promise<AXPBackgroundOperation>;
+    cancel(operationId: string): Promise<void>;
+    pause(operationId: string): Promise<void>;
+    resume(operationId: string): Promise<void>;
+    retry(operationId: string): Promise<void>;
+    dismiss(operationId: string): Promise<void>;
+    hasClickHandler(operation: AXPBackgroundOperation): boolean;
+    executeCommand(operationId: string, command: AXPExecuteCommand): Promise<void>;
+    executeClick(operationId: string): Promise<void>;
+    runAction(operationId: string, action: AXPBackgroundOperationActionKey): Promise<void>;
+    private resolveHandler;
+    private resolveProvider;
+    private resolveOperation;
+    private run;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBackgroundOperationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPBackgroundOperationService>;
+}
+
+declare class AXPBackgroundOperationSlotComponent {
+    private readonly operationService;
+    private readonly popover;
+    protected readonly activeCount: i0.Signal<number>;
+    protected readonly failedCount: i0.Signal<number>;
+    protected readonly showSlot: i0.Signal<boolean>;
+    protected readonly slotShowsFailureOnly: i0.Signal<boolean>;
+    protected readonly slotLabelKey: i0.Signal<"@general:background-operation.slot.failed-single" | "@general:background-operation.slot.failed-multiple" | "@general:background-operation.slot.single" | "@general:background-operation.slot.multiple">;
+    protected readonly slotLabelParams: i0.Signal<{
+        count: number;
+    }>;
+    protected closePopover(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBackgroundOperationSlotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPBackgroundOperationSlotComponent, "axp-background-operation-slot", never, {}, {}, never, never, true, never>;
+}
+
+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>;
+}
+
+/** Thrown when a requested platform resource cannot be resolved. */
+declare class AXPNotFoundError extends Error {
+    constructor(message?: string);
+}
+
+/** Canonical route path for the platform 404 page. */
+declare const AXP_NOT_FOUND_ROUTE = "/error/404";
+/**
+ * Catch-all route that redirects unknown URLs to the platform 404 page.
+ * Register this as the **last** route source in the application (after all app and module routes).
+ */
+declare const AXP_NOT_FOUND_CATCH_ALL_ROUTE: Route;
+/**
+ * Registers the platform catch-all 404 route.
+ * Must be the last `ROUTES` provider in `app.config` so custom app routes are matched first.
+ */
+declare function AXPNotFoundCatchAllRoute(): EnvironmentProviders;
+/**
+ * Returns true when an entity byKey query did not resolve a record.
+ */
+declare function axpIsEntityRecordNotFound(data: unknown): boolean;
+/**
+ * Creates an Angular redirect command to the platform 404 page.
+ */
+declare function axpRedirectToNotFound(router?: Router): RedirectCommand;
+
+/** Canonical route path for the platform 401 page. */
+declare const AXP_UNAUTHORIZED_ROUTE = "/error/401";
+/**
+ * Creates an Angular redirect command to the platform 401 page.
+ */
+declare function axpRedirectToUnauthorized(router?: Router): RedirectCommand;
+
+interface AXPKeyboardShortcutHelpGroup {
+    label: string;
+    items: AXPKeyboardShortcutHelpEntry[];
+}
+declare class AXPKeyboardShortcutsHelpComponent {
+    private readonly shortcutRegistry;
+    protected readonly groups: i0.Signal<AXPKeyboardShortcutHelpGroup[]>;
+    protected chordToKbdKeys(chord: string): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPKeyboardShortcutsHelpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPKeyboardShortcutsHelpComponent, "axp-keyboard-shortcuts-help", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPKeyboardShortcutsHelpService {
+    private readonly popupService;
+    private readonly translationService;
+    private readonly shortcutRegistry;
+    private readonly document;
+    /** In-flight help popup session (open until the popup closes). */
+    private activeShow;
+    constructor();
+    /**
+     * Opens the keyboard shortcuts help popup, or no-ops when it is already open.
+     */
+    show(): Promise<void>;
+    private openHelpPopup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPKeyboardShortcutsHelpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPKeyboardShortcutsHelpService>;
+}
+
+interface AXPCommonModuleConfigs {
+    errorHandlers: (new () => AXPErrorHandler)[];
+}
+declare class AXPCommonModule {
+    static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[], _keyboardShortcutsHelp: AXPKeyboardShortcutsHelpService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPCommonModule, never, [typeof i1.AXPComponentSlotModule, typeof i2.AXPWorkflowModule, typeof i3.AXPopupModule, typeof i4.AXDateTimeModule, typeof i5.AXToastModule, typeof i1.AXPModuleManifestModule], [typeof _angular_router.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",
+    ConfirmUnsavedChanges = "Common:Setting:Entity.ConfirmUnsavedChanges",
+    DebugMode = "PlatformDevTools:Setting:Developer.DebugMode",
+    ShowRowIndexColumn = "Common:Setting:Entity.ShowRowIndexColumn",
+    EntityListPersistenceMode = "Common:Setting:Entity.ListPersistenceMode"
+}
+
+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>;
+}
+
+/**
+ * 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;
+
+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>;
+}
+
+declare class AXPFileStorageEvaluatorScopeProvider implements AXPExpressionEvaluatorScopeProvider {
+    fileStorageService: AXPFileStorageService;
+    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
+}
+
+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>;
+}
+
+/**
+ * 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[];
+    };
+    /**
+     * Keyboard shortcuts for this menu item.
+     * Use a chord string or `{ keys, allowInEditableFields, ... }`. Pass `[]` to disable.
+     */
+    shortcuts?: AXPKeyboardShortcut[];
+}
+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;
+    };
+}>>;
+
+declare class AXPMenuKeyboardShortcutService {
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly shortcutRegistry;
+    private readonly visibilityService;
+    private readonly sessionService;
+    private readonly isAuthenticated;
+    /**
+     * Registers global keyboard shortcuts declared on menu items (`shortcuts` property).
+     * Replaces the previous registration when the menu tree is reloaded.
+     */
+    sync(items: AXPMenuItem[]): void;
+    private buildShortcutBindings;
+    private collectShortcutEntries;
+    private isShortcutActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuKeyboardShortcutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuKeyboardShortcutService>;
+}
+
+/**
+ * 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 visibility for a menu branch, including ancestor policies.
+     * Parent module features and permissions must pass before child routes are accessible.
+     */
+    isMenuBranchVisible(item: AXPMenuItem, ancestors?: AXPMenuItem[]): boolean;
+    /**
+     * 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 AXPMenuRouteMatchResult {
+    item: AXPMenuItem;
+    /** Parent menu items from root down to the direct parent of the matched item. */
+    ancestors: AXPMenuItem[];
+    isPartialMatch: boolean;
+}
+/**
+ * Compares a menu item path with the current browser path.
+ * Mirrors the matching rules used when selecting the active menu item.
+ */
+declare function axpMenuPathsMatch(itemPath: string, currentPath: string, trailingSegmentsToIgnore?: string[]): {
+    isMatch: boolean;
+    isPartial: boolean;
+};
+/**
+ * Finds the most specific menu item that matches the given route path.
+ */
+declare function axpFindMenuItemByRoute(items: AXPMenuItem[], currentPath: string, trailingSegmentsToIgnore?: string[]): AXPMenuRouteMatchResult | null;
+
+/**
+ * Resolves route access using menu policy, route metadata, permissions, and features.
+ */
+declare class AXPMenuRouteAccessService {
+    private readonly menuProvider;
+    private readonly menuVisibility;
+    private readonly sessionService;
+    /**
+     * Checks whether navigation to the target URL is allowed for the current user.
+     */
+    canAccess(route: ActivatedRouteSnapshot, url: string): Promise<boolean>;
+    private shouldSkip;
+    private hasRouteFlag;
+    private hasExplicitRouteAccess;
+    private getInheritedRouteData;
+    private normalizeKeys;
+    private normalizeUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuRouteAccessService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuRouteAccessService>;
+}
+
+/**
+
+ * Blocks navigation when the target route is not accessible for the current user.
+
+ * Evaluates menu policy, permissions, and features.
+
+ */
+declare const AXPMenuRouteGuard: CanActivateFn;
+
+/** Standard guards for authenticated routes with menu-based access enforcement. */
+declare const AXP_PROTECTED_ROUTE_GUARDS: readonly [_angular_router.CanActivateFn, _angular_router.CanActivateFn];
+
+interface AXPSearchDefinitionDisplayFormat {
+    title?: string;
+    description?: string;
+    icon?: string;
+    id?: string;
+    /** Entity `single.title` / lookup / individual templates when primary `title` is empty. */
+    titleFallbackTemplates?: string[];
+    /** Entity property paths (from schema) when templates do not resolve. */
+    titleFallbackFields?: 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 | AXPMultiLanguageString;
+    description?: string | AXPMultiLanguageString;
+    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 | AXPMultiLanguageString;
+    description?: string | AXPMultiLanguageString;
+    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 {
+    private readonly translationService;
+    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;
+    private expressionEvaluator;
+    search(text: string): Promise<AXPSearchDisplayGroupResult[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSearchService>;
+}
+
+/**
+ * Resolves a value to plain text for global-search matching (i18n keys, locale maps, scalars).
+ */
+declare function resolveSearchableText(value: unknown, locale: string, translationService: AXTranslationService): string;
+/**
+ * Case-insensitive match against i18n keys, locale maps, and plain strings.
+ */
+declare function searchInSearchableValue(value: unknown, query: string, locale: string, translationService: AXTranslationService): boolean;
+/**
+ * Shallow + nested search over entity/command payloads (skips id / entityName keys).
+ */
+declare function searchInRecordValues(value: unknown, query: string, locale: string, translationService: AXTranslationService, depth?: number): boolean;
+/** Standard row scope for entity title/search templates. */
+declare function createEntityRowExpressionScope(data: unknown): AXPExpressionEvaluatorScope;
+/**
+ * Evaluates a normalized entity display template via {@link AXPExpressionEvaluatorService}.
+ */
+declare function evaluateEntityDisplayTemplate(template: string, data: unknown, expressionEvaluator: AXPExpressionEvaluatorService, locale: string, translationService: AXTranslationService): Promise<unknown>;
+/**
+ * Best display string from row values that contain the active search query (deep-match fallback).
+ */
+declare function resolveQueryMatchingDisplayText(value: unknown, query: string, locale: string, translationService: AXTranslationService, depth?: number): string;
+/**
+ * Resolves entity search display templates; coerces multi-language field values to readable text.
+ */
+declare function resolveSearchDisplayTemplate(template: string | undefined, data: unknown, locale: string, translationService: AXTranslationService, formatService: AXFormatService, expressionEvaluator: AXPExpressionEvaluatorService): Promise<AXPMultiLanguageString>;
+
+interface AXPEntitySearchTitleContext {
+    /** Templates tried after the primary `searchResult.title` fails (`single.title`, lookup, individual). */
+    fallbackTemplates: string[];
+    /** Entity property paths tried when templates do not resolve (`lookup`, identifier, common fields). */
+    fallbackFields: string[];
+}
+/**
+ * Normalizes entity display templates for {@link AXPExpressionEvaluatorService}.
+ * Converts `context.eval('path')`, single braces, and simple dot paths to `context.eval` segments.
+ */
+declare function normalizeEntityDisplayTemplate(template: string): string;
+/** True when formatted text still contains unresolved template markers. */
+declare function isUnresolvedEntityDisplayTemplate(value: string): boolean;
+/**
+ * Strips literal `undefined` / `null` tokens produced when expression segments are missing.
+ */
+declare function sanitizeResolvedEntityDisplayTitle(value: string): string;
+/** True when a resolved title is non-empty and safe to show in search or entity chrome. */
+declare function isMeaningfulEntityDisplayTitle(value: string): boolean;
+/**
+ * Builds entity-scoped fallback metadata for global search (registered on each entity search definition).
+ */
+declare function buildEntitySearchTitleContext(entity: AXPEntity, primaryTemplate?: string): AXPEntitySearchTitleContext;
+/**
+ * Row title template chain aligned with entity layouts.
+ * Priority: `interfaces.master.single.title` → `formats.searchResult.title` → `formats.individual`.
+ */
+declare function resolveEntityRowTitleTemplate(entity: AXPEntity | null | undefined): string | undefined;
+/**
+ * Resolves an entity row title using entity-driven fallback templates and property paths.
+ */
+declare function resolveEntitySearchTitleFallback(format: Pick<AXPSearchDefinitionDisplayFormat, 'titleFallbackTemplates' | 'titleFallbackFields'>, data: unknown, locale: string, translationService: AXTranslationService, formatService: AXFormatService, expressionEvaluator: AXPExpressionEvaluatorService): Promise<string>;
+
+interface AXPResolveEntityRowDisplayTitleOptions {
+    /** Row or form context data used to evaluate title templates. */
+    data: Record<string, unknown> | undefined;
+    activeLang: string;
+    formatService: AXFormatService;
+    /** Entity definition when available (forms, columns with entity resolver). */
+    entity?: AXPEntity | null;
+    /** Widget/interface options — may contain `popupTitle` or `titleTemplate`. */
+    widgetOptions?: Record<string, unknown> | undefined;
+}
+/** Row path used when context carries a nested entity layout title. */
+declare const ENTITY_LAYOUT_SINGLE_TITLE_PATH = "entity.layout.single.title";
+/** Widget option for a pre-evaluated or template entity row title (entity list column mappers). */
+declare const ENTITY_ROW_POPUP_TITLE_OPTION = "popupTitle";
+/** Widget option alias for entity row title templates in view/edit forms. */
+declare const ENTITY_ROW_TITLE_TEMPLATE_OPTION = "titleTemplate";
+/** Resolves a row field or format result to a plain display string for the active locale. */
+declare function resolveEntityRowDisplayText(value: unknown, activeLang: string): string;
+/**
+ * Resolves an entity row title for list columns, view widgets, and edit widgets.
+ * Uses entity metadata when provided, otherwise widget title templates and common field paths.
+ */
+declare function resolveEntityRowDisplayTitle(options: AXPResolveEntityRowDisplayTitleOptions): string;
+/**
+ * @deprecated Use {@link resolveEntityRowDisplayTitle} instead.
+ */
+declare function resolveEntityRowDisplayTitleFromColumnContext(rowData: Record<string, unknown> | undefined, columnOptions: Record<string, unknown> | undefined, formatService: AXFormatService, activeLang: string): string;
+/**
+ * Formats the entity row title for display using entity-driven templates and property paths.
+ */
+declare function formatEntityRowDisplayTitle(entity: AXPEntity | null | undefined, rowData: Record<string, unknown> | undefined, formatService: AXFormatService, activeLang: string): string;
+
+/**
+ * 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;
+
+declare class AXPSettingDefinitionProviderContext {
+    private rootGroups;
+    private groupMap;
+    addGroup(name: string, title: string, description?: string, icon?: string, pageTitle?: string, priority?: number): 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, pageTitle?: string, priority?: number): 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?: AXPSettingLayoutOptions;
+        };
+        description?: string;
+        searchTagKeys?: string[];
+        isRequired?: boolean;
+        isInherited?: boolean;
+        isEncrypted?: boolean;
+        defaultValue?: unknown;
+        valueTransforms?: AXPValueTransformerFunctions;
+        validationRules?: AXPValidationRules;
+    }): this;
+    endSection(): AXPSettingDefinitionGroupBuilder;
+}
+
+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;
+    /**
+     * When set, missing values from this provider are persisted at this scope instead of each
+     * setting's definition scope. Use for app-wide demo or deployment defaults (e.g. platform).
+     */
+    scope?: AXPPlatformScope;
+    /** 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[];
+}
+/** Layout options for a single setting row on the settings page. */
+interface AXPSettingLayoutOptions extends AXPGridLayoutOptions {
+    /** When true, stack the label above a full-width control. */
+    stacked?: boolean;
+}
+interface AXPSettingDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    /** Optional i18n keys (e.g. `@scope:key`) whose translated values are included in settings search. */
+    searchTagKeys?: string[];
+    widget: AXPWidgetNode;
+    layout?: AXPSettingLayoutOptions;
+    scope: AXPPlatformScopeKey;
+    isRequired?: boolean;
+    isInherited?: boolean;
+    isEncrypted?: boolean;
+    defaultValue?: unknown;
+    value?: unknown;
+}
+interface AXPSettingDefinitionGroup {
+    name: string;
+    /** Short label (e.g. sidebar); i18n key when using the translation pipe. */
+    title: string;
+    /** Optional fuller page heading; i18n key. When omitted, `title` is used for the page header. */
+    pageTitle?: string;
+    icon?: string;
+    description?: string;
+    /** Sidebar order; lower numbers appear first. Defaults to 1000 when omitted. */
+    priority?: number;
+    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;
+}
+
+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>>;
+    settingScopeByKey(): Promise<Record<string, AXPPlatformScope>>;
+    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[]>;
+interface AXPSettingMergedDefaults {
+    defaults: Record<string, unknown>;
+    /** Per-key scope override for seeding (from providers that set `scope`). */
+    seedScopeByKey: Record<string, AXPPlatformScope>;
+}
+declare class AXPSettingDefaultValuesAggregatorService {
+    private readonly definitionService;
+    private readonly providers;
+    getMerged(): Promise<AXPSettingMergedDefaults>;
+    getDefaults(): Promise<Record<string, unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefaultValuesAggregatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingDefaultValuesAggregatorService>;
+}
+
+declare const AXP_SETTING_VALUE_PROVIDER: InjectionToken<AXPSettingValueProvider[]>;
+
+/**
+ * Supported primitive coercions for persisted setting values (including `{ value: ... }` wrappers).
+ */
+type AXPSettingCoercionKind = 'string' | 'boolean' | 'number' | 'date';
+/**
+ * If the payload uses the common `{ value: T }` shape from setting widgets, returns the inner value; otherwise returns `raw`.
+ */
+declare function peelSettingValueKey(raw: unknown): unknown;
+/**
+ * Picks a primitive coercion kind from the setting definition default and/or the effective stored value.
+ * Type argument `T` on the settings service `get` method is compile-time only; runtime behavior follows this inference.
+ */
+declare function inferSettingCoercionKind(defaultSample: unknown, effective: unknown): AXPSettingCoercionKind | null;
+declare function coerceAXPSettingRawValueByKind(raw: unknown, kind: AXPSettingCoercionKind): string | boolean | number | Date;
+declare function coerceAXPSettingRawValue(raw: unknown, kind: 'string'): string;
+declare function coerceAXPSettingRawValue(raw: unknown, kind: 'boolean'): boolean;
+declare function coerceAXPSettingRawValue(raw: unknown, kind: 'number'): number;
+declare function coerceAXPSettingRawValue(raw: unknown, kind: 'date'): Date;
+
+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[]>;
+    /**
+     * Returns the effective setting value. Primitive coercion (string, boolean, number, date) is inferred from the
+     * definition default and/or the stored shape (including `{ value: ... }`). Type argument `T` is compile-time only;
+     * it is not read at runtime—use it to document the expected result (e.g. `get<boolean>(key)`).
+     */
+    get<T = any>(key: string): Promise<T>;
+    /**
+     * Effective value (user → tenant → platform) when set; otherwise the definition default. Used for reads and coercion hints.
+     */
+    private resolveEffectiveAndDefault;
+    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
+    scope(scope: AXPPlatformScope): ScopedSettingService;
+    invokeChangeEvent(event: AXPSettingChangedEvent): void;
+    private seedMissingDefaults;
+    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>;
+}
+
+/**
+ * Platform-provided {@link AXCalendarService} that applies locale profile week layout
+ * (first day of week, weekends) through the core calendar service lifecycle.
+ *
+ * Temporary bridge until @acorex/components reads week layout from AXLocaleService.
+ */
+declare class AXPRegionalCalendarService extends AXCalendarService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPRegionalCalendarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPRegionalCalendarService>;
+}
+
+/**
+ * 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",
+    /** User-selected holiday calendars shown on the task board and other calendar views. */
+    CalendarEvents = "LocaleManagement:Setting:Regional.CalendarEvents",
+    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"
+}
+
+interface AXPUnsavedChangesConfirmOptions {
+    /** When false, skips confirm even if the global setting is enabled (e.g. dialog `confirmCloseWhenDirty`). */
+    enabled?: boolean;
+    title?: AXPMultiLanguageString;
+    message?: AXPMultiLanguageString;
+    /**
+     * When true (default), confirming sets leave approval for the next route deactivation.
+     * Set false for in-place actions such as discarding edits without navigating away.
+     */
+    approveLeaveOnConfirm?: boolean;
+}
+interface AXPUnsavedChangesCanDeactivate {
+    canDeactivate(): boolean | Promise<boolean>;
+}
+declare class AXPUnsavedChangesConfirmService {
+    private readonly settingsService;
+    private readonly dialogService;
+    private readonly translateService;
+    /** Ensures concurrent leave paths share a single unsaved-changes confirm dialog. */
+    private confirmPromise?;
+    /** Set after the user confirms leaving; cleared on {@link NavigationEnd} by popstate handler. */
+    private leaveConfirmed;
+    /**
+     * Whether the global "confirm unsaved changes" setting is enabled.
+     */
+    isGloballyEnabled(): Promise<boolean>;
+    /**
+     * Marks the next route deactivation as already approved (avoids a second prompt after in-app navigation).
+     */
+    markLeaveConfirmed(): void;
+    /** True while an unsaved-changes confirm dialog is open or being resolved. */
+    isConfirmPending(): boolean;
+    /** Whether the user already approved leaving during the current navigation. */
+    hasLeaveConfirmed(): boolean;
+    /** Clears leave approval after navigation settles. */
+    clearLeaveConfirmed(): void;
+    consumeLeaveConfirmed(): boolean;
+    /**
+     * Prompts when `isDirty` and the global setting (and optional per-instance `enabled`) allow it.
+     * Returns true when navigation/dismiss may proceed.
+     */
+    confirmIfDirty(isDirty: boolean, options?: AXPUnsavedChangesConfirmOptions): Promise<boolean>;
+    private resolveConfirmIfDirty;
+    private prompt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPUnsavedChangesConfirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPUnsavedChangesConfirmService>;
+}
+
+interface AXPUnsavedChangesPopstateSource {
+    id: string;
+    isDirty: () => boolean;
+}
+/**
+ * Intercepts browser back/forward (`popstate`) when a registered page is dirty.
+ * Captures dirty state synchronously on {@link NavigationStart}, restores the current URL
+ * before route activation, prompts once, then re-triggers `history.back()` only if confirmed.
+ */
+declare class AXPUnsavedChangesPopstateService {
+    private readonly router;
+    private readonly location;
+    private readonly confirm;
+    private readonly destroyRef;
+    private sources;
+    private committedUrl;
+    private handling;
+    constructor();
+    registerSource(source: AXPUnsavedChangesPopstateSource): void;
+    unregisterSource(id: string): void;
+    /** True while a popstate back/forward is being intercepted or confirmed. */
+    isHandlingPopstate(): boolean;
+    private handlePopstateNavigation;
+    private isDirty;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPUnsavedChangesPopstateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPUnsavedChangesPopstateService>;
+}
+
+declare function createUnsavedChangesCanDeactivateGuard<T extends AXPUnsavedChangesCanDeactivate>(): CanDeactivateFn<T>;
+
+/**
+ * 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;
+    /**
+     * Best-effort plain string for {@link Error} messages (no i18n lookup).
+     */
+    private commandMessageTextForError;
+    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",
+    WaitingSignOff = "waiting-sign-off",
+    WaitingApproval = "waiting-approval",
+    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 WaitingSignOff: {
+        readonly name: AXPSystemStatusType.WaitingSignOff;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly WaitingApproval: {
+        readonly name: AXPSystemStatusType.WaitingApproval;
+        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 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>;
+}
+
+interface AXPAppPathParts {
+    segments: string[];
+    queryParams?: Record<string, string>;
+    fragment?: string;
+}
+/**
+ * Splits an absolute app path (`/app/m/module/e/Entity/id/view`) into router command segments.
+ * Prefer this over `navigate([fullPath])` or ambiguous single-segment navigation so browser history stays correct.
+ */
+declare function axpParseAppPath(path: string): AXPAppPathParts;
+/** Navigates using explicit path segments (same pattern as entity preload filters). */
+declare function axpNavigateAppPath(router: Router, path: string, extras?: NavigationExtras): Promise<boolean>;
+/** True when a URL path is an entity master list route (`.../e/{Entity}/list`). */
+declare function axpIsEntityListPath(url: string): boolean;
+/** True when the current browser URL is an entity master list route (`.../e/{Entity}/list`). */
+declare function axpIsEntityListRoute(router: Router): boolean;
+/** True when a URL path is an entity details view route (`.../e/{Entity}/{id}/view`). */
+declare function axpIsEntityDetailsPath(url: string): boolean;
+/** True when the current browser URL is an entity details view route (`.../e/{Entity}/{id}/view`). */
+declare function axpIsEntityDetailsViewRoute(router: Router): boolean;
+/**
+ * Merges query params on the current entity list route without pushing history.
+ * Uses absolute path segments so a stale `relativeTo` cannot rewrite the active URL after navigating away.
+ */
+declare function axpReplaceEntityListRouteQueryParams(router: Router, queryParams: Record<string, string | null | undefined>): void;
+
+declare class AXPClipBoardService {
+    private readonly toast;
+    private readonly translationService;
+    copy(title: string, value: string): Promise<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>;
+}
+
+type AXPGraphicDownloadFormat = 'svg' | 'png' | 'jpeg';
+interface AXPGraphicPrintContent {
+    bodyMarkup: string;
+    styleRule: string;
+}
+interface AXPPrintGraphicOptions {
+    /** Used when the rendered element has no measurable size. */
+    fallbackSize?: number;
+    title?: string;
+    imageAlt?: string;
+}
+interface AXPGraphicDownloadOptions {
+    format: AXPGraphicDownloadFormat;
+    filename: string;
+    /** Used when rasterizing SVG or sizing canvas output. */
+    fallbackSize?: number;
+}
+/**
+ * Normalizes widget option values to a positive finite number
+ * (plain number, numeric string, or editor object with `value` / `id`).
+ */
+declare function normalizePositiveNumberOption(value: unknown, fallback: number): number;
+/**
+ * Resolves the rendered graphic size from a container (canvas or SVG).
+ */
+declare function resolveGraphicElementSize(container: HTMLElement, fallback: number): number;
+/**
+ * Serializes an SVG element to a string, optionally prefixing the XML declaration.
+ */
+declare function serializeSvgElement(svg: SVGSVGElement, includeXmlDeclaration?: boolean): string;
+/**
+ * Builds printable HTML body markup and CSS for an SVG or canvas inside a container.
+ */
+declare function resolveGraphicPrintContent(container: HTMLElement, size: number, imageAlt?: string): AXPGraphicPrintContent | undefined;
+/**
+ * Triggers a file download for the given blob via a temporary anchor element.
+ */
+declare function triggerBrowserDownload(blob: Blob, filename: string): void;
+/**
+ * Opens the system print dialog for an SVG or canvas graphic inside the given container.
+ */
+declare function printGraphicFromElement(container: HTMLElement, options?: AXPPrintGraphicOptions): void;
+/**
+ * Downloads an SVG or canvas graphic from a container as SVG, PNG, or JPEG.
+ */
+declare function downloadGraphicFromElement(container: HTMLElement, options: AXPGraphicDownloadOptions): void;
+
+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>;
+    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, AXPBackgroundOperationCompletionService, AXPBackgroundOperationEntityStoreService, AXPBackgroundOperationHandler, AXPBackgroundOperationNotificationService, AXPBackgroundOperationProvider, AXPBackgroundOperationRootConfig, AXPBackgroundOperationService, AXPBackgroundOperationSlotComponent, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPEntityType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPKeyboardShortcutsHelpComponent, AXPKeyboardShortcutsHelpService, AXPLockService, AXPMenuItemsDataSourceDefinition, AXPMenuKeyboardShortcutService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuRouteAccessService, AXPMenuRouteGuard, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPNotFoundCatchAllRoute, AXPNotFoundError, AXPOutputContractTranscriptSegmentService, AXPPlatformCommonDataSourceKeys, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalCalendarService, 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, AXPUnsavedChangesConfirmService, AXPUnsavedChangesPopstateService, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES, AXP_APP_VERSION_PROVIDER, AXP_BACKGROUND_OPERATION_ENTITY_STORAGE, AXP_BACKGROUND_OPERATION_HANDLERS, AXP_BACKGROUND_OPERATION_PROVIDERS, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_IN_APP_NOTIFICATION_SERVICE, AXP_LOCALE_MANAGEMENT_PORT, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_NOT_FOUND_CATCH_ALL_ROUTE, AXP_NOT_FOUND_ROUTE, AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_PROTECTED_ROUTE_GUARDS, 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, AXP_UNAUTHORIZED_ROUTE, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, DEFAULT_DATE_FILTER_PRESETS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENTITY_LAYOUT_SINGLE_TITLE_PATH, ENTITY_ROW_POPUP_TITLE_OPTION, ENTITY_ROW_TITLE_TEMPLATE_OPTION, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, MULTILANGUAGE_CAPABLE_WIDGET_TYPES, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, axpBackgroundOperationCapabilities, axpBackgroundOperationDisplayTime, axpBackgroundOperationEntityName, axpBackgroundOperationEstimateEndDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationFromEntityModel, axpBackgroundOperationRemainingMs, axpBackgroundOperationToEntityModel, axpBuildBackgroundOperation, axpCoerceBackgroundOperationDate, axpCreateBackgroundOperationId, axpFindMenuItemByRoute, axpIsActiveBackgroundOperationStatus, axpIsCompletedBackgroundOperationStatus, axpIsEntityDetailsPath, axpIsEntityDetailsViewRoute, axpIsEntityListPath, axpIsEntityListRoute, axpIsEntityRecordNotFound, axpMenuPathsMatch, axpNavigateAppPath, axpParseAppPath, axpRedirectToNotFound, axpRedirectToUnauthorized, axpReplaceEntityListRouteQueryParams, backgroundOperationEntityFactory, buildEntitySearchTitleContext, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createAllQueryView, createBackgroundOperationStore, createEntityCommandOptions, createEntityRowExpressionScope, createEntitySearchCommand, createMenuContext, createMenuMiddleware, createQueryView, createUnsavedChangesCanDeactivateGuard, downloadGraphicFromElement, evaluateEntityDisplayTemplate, findManualPresetIdByOperation, formatEntityRowDisplayTitle, getEntityInfo, getStatusInfo, getSystemStatus, inferSettingCoercionKind, isCardFieldBadgeDisplay, isMeaningfulEntityDisplayTitle, isUnresolvedEntityDisplayTemplate, normalizeEntityDisplayTemplate, normalizePositiveNumberOption, peelSettingValueKey, printGraphicFromElement, provideDynamicHomePage, provideMenuMiddleware, resolveCardFieldBadgeColor, resolveDateFilterPresets, resolveDefaultMasterListLayout, resolveEnabledMasterListLayouts, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle, resolveEntityRowDisplayTitleFromColumnContext, resolveEntityRowTitleTemplate, resolveEntitySearchTitleFallback, resolveGraphicElementSize, resolveGraphicPrintContent, resolveQueryMatchingDisplayText, resolveSearchDisplayTemplate, resolveSearchableText, resolveStatusLook, sanitizeResolvedEntityDisplayTitle, searchInRecordValues, searchInSearchableValue, serializeSvgElement, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, systemStatusToDefinition, triggerBrowserDownload, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
+export type { AXCFileUploaderAction, AXCFileUploaderActionsPayload, AXCFileUploaderCapabilities, AXEntityPropertyWidget, AXPAgentOutputContract, AXPAgentOutputKind, AXPAgentResponseFormat, AXPAggregate, AXPAppPathParts, AXPAppVersion, AXPAppVersionProvider, AXPApplication, AXPBackgroundOperation, AXPBackgroundOperationActionKey, AXPBackgroundOperationCapabilities, AXPBackgroundOperationCreateRequest, AXPBackgroundOperationEntityModel, AXPBackgroundOperationEntityStorageAdapter, AXPBackgroundOperationError, AXPBackgroundOperationFailureMode, AXPBackgroundOperationFailurePolicy, AXPBackgroundOperationProviderStore, AXPBackgroundOperationStatus, AXPCardBadgeColor, AXPCardBadgeDisplay, AXPCardBadgeDisplayOptions, AXPCardField, AXPCardFieldDisplay, AXPCardFieldDisplayConfig, AXPCategoryEntity, AXPColumnAlign, AXPColumnContentAlign, AXPCommandActionCallback, AXPCommandActionDisplay, AXPCommandActionLook, AXPCommandActionPriority, AXPCommandActionType, AXPCommonModuleConfigs, AXPCurrency, AXPDateTimeFilterPreset, AXPDateTimeFilterPresetKind, AXPDateTimeFilterValue, AXPDomToImageOptions, AXPEntity, AXPEntityAction, AXPEntityCommand, AXPEntityDetailListView, AXPEntityDisplayField, AXPEntityMasterCreateLayoutView, AXPEntityMasterLayoutView, AXPEntityMasterListDisplayMode, AXPEntityMasterListLayoutOption, AXPEntityMasterListLayoutType, AXPEntityMasterListView, AXPEntityMasterSingleLayoutView, AXPEntityMasterUpdateLayoutView, AXPEntityPage, AXPEntityProperty, AXPEntityPropertyCreateView, AXPEntityPropertyGroup, AXPEntityPropertyLayoutConfig, AXPEntityPropertyUpdateView, AXPEntityPropertyView, AXPEntityQuery, AXPEntityQuickCreate, AXPEntitySearchTitleContext, AXPEntitySectionView, AXPEntityTableColumn, AXPEntityV2, AXPEntityVersionHistory, AXPErrorHandler, AXPFileActionProvider, AXPFileActionProviderToken, AXPFileExtension, AXPFileType, AXPFileTypeInfoProvider, AXPFilterOperator, AXPGeoLocation, AXPGraphicDownloadFormat, AXPGraphicDownloadOptions, AXPGraphicPrintContent, AXPGroupSearchResult, AXPHomePageDefinition, AXPInAppNotificationCreateRequest, AXPInAppNotificationPriority, AXPInAppNotificationService, AXPJsonSchemaLike, AXPLanguage, AXPLocaleManagementPort, AXPLocaleProfile, AXPLockGetInfoRequest, AXPLockInfo, AXPLockRequest, AXPLockType, AXPMenuFinderResult, AXPMenuInsertion, AXPMenuItem, AXPMenuItemCommand, AXPMenuItemFinder, AXPMenuItemWithParent, AXPMenuMiddleware, AXPMenuMiddlewareContext, AXPMenuMiddlewareProvider, AXPMenuProvider, AXPMenuProviderContext, AXPMenuRouteMatchResult, AXPMenuType, AXPModule, AXPOutputContractTranscriptSegmentDefinition, AXPOutputContractTranscriptSegmentProvider, AXPOutputContractTranscriptSegmentProviderToken, AXPOutputTranscriptSegmentId, AXPPlatformConfigs, AXPPrintGraphicOptions, AXPQueryFilter, AXPQuerySort, AXPQueryView, AXPRelatedEntity, AXPRelationship, AXPResolveEntityRowDisplayTitleOptions, AXPRootConfigs, AXPSearchAction, AXPSearchDefinition, AXPSearchDefinitionDisplayFormat, AXPSearchDefinitionProvider, AXPSearchDisplayGroupResult, AXPSearchDisplayResult, AXPSearchDisplayResultForSave, AXPSearchParentResult, AXPSearchProvider, AXPSearchResult, AXPSettingChangedEvent, AXPSettingCoercionKind, AXPSettingDefaultValuesProvider, AXPSettingDefinition, AXPSettingDefinitionGroup, AXPSettingDefinitionProvider, AXPSettingDefinitionSection, AXPSettingLayoutOptions, AXPSettingMergedDefaults, AXPSettingValue, AXPSettingValueProvider, AXPSettingsServiceInterface, AXPStatusDefinition, AXPStatusTransition, AXPTimeZone, AXPTokenDefinition, AXPTokenDefinitionProvider, AXPTokenDefinitionProviderToken, AXPUnLockRequest, AXPUnsavedChangesCanDeactivate, AXPUnsavedChangesConfirmOptions, AXPUnsavedChangesPopstateSource, AXPVersionChange, AXPVersionEntry, AXPVersionStream, CanonicalChange, CanonicalChangeOp, VersionedFileInfo };