@acorex-platform/framework-client 0.0.10

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

@@ -0,0 +1,3287 @@
+import * as _acorex_platform_framework_shared_core from '@acorex-platform/framework-shared/core';
+import { AXPAgentOutputKind, AXPOutputTranscriptSegmentId, AXPUserReference, AXPExecuteCommand, AXPKeyboardShortcutHelpEntry, AXPLogoConfig, AXPWidgetNode, AXPGridLayoutOptions, AXPPlatformScopeKey, AXPPlatformScope, AXPFileListItem, AXPFileStorageCreateRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFileStorageFindRequest, AXPFileManyStorageInfo, AXPMetaDataDefinition, AXPIntegrationProviderDefinition, AXPIntegrationRuntimeContext, AXPIntegrationSecretPayload, AXPIntegrationAuthContext, AXPIntegrationResolvedCredentials, AXPSafeIntegrationConnectionDto, AXPMetaData, AXPKeyboardShortcut, AXPSystemActionType, AXPMultiLanguageString, AXPApplicationUserReference, AXPEntityReference, AXPOptionsData, AXPWidgetTriggers, AXPValidationRules, AXPStatusProvider, AXPStatusTransition } from '@acorex-platform/framework-shared/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Signal, Injector, ErrorHandler, ModuleWithProviders, EventEmitter, ElementRef, Renderer2, NgZone, ChangeDetectorRef } from '@angular/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, DetachedRouteHandle } from '@angular/router';
+import { AXPEntity, AXPCommandActionLook, AXPCommandActionPriority, AXPEntityProperty } from '@acorex-platform/framework-shared/entity';
+import { AXFormatterRegistryService, AXFormatter, AXFormatOptions, AXFormatService } from '@acorex/core/format';
+import * as i1 from '@acorex-platform/framework-client/core';
+import { AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext, AXPDataSourceDefinitionProvider, AXPDataSourceDefinition, AXPNavigateActionCommand, AXPContextEvalFactory, AXPExpressionEvaluatorScope, AXPExpressionEvaluatorService, AXPValueTransformerFunctions } from '@acorex-platform/framework-client/core';
+export { AXPDebugService } from '@acorex-platform/framework-client/core';
+import * as i2 from '@acorex-platform/framework-client/workflow';
+import { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflow } from '@acorex-platform/framework-client/workflow';
+import * as i3 from '@acorex/components/popup';
+import { AXPopupService } from '@acorex/components/popup';
+import * as i5 from '@acorex/components/toast';
+import * as rxjs from 'rxjs';
+import { Subject, ReplaySubject } from 'rxjs';
+import { AXDataSourceFilterOption, AXDataSourceOperator, AXStyleColorType } from '@acorex/cdk/common';
+import * as _ngrx_signals from '@ngrx/signals';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPWidgetProperty, AXPWidgetTypesMap } from '@acorex-platform/framework-shared/widget-core';
+import Dexie, { Table } from 'dexie';
+import { AXLocaleProfile } from '@acorex/core/locale';
+
+/** Platform common datasource registry names. */
+declare const AXPPlatformCommonDataSourceKeys: {
+    readonly MenuItems: "platform-menu-items";
+};
+
+/**
+ * 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 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>;
+}
+
+declare class AXPBrowserTitleService {
+    private readonly document;
+    private readonly translateService;
+    private readonly tabNavigation;
+    private readonly menuService;
+    private readonly sessionService;
+    private readonly router;
+    private readonly destroyRef;
+    private readonly simpleModePageTitle;
+    private readonly localeRevision;
+    private readonly sessionRevision;
+    private readonly routeRevision;
+    constructor();
+    /** Publishes the resolved page title for the given route key (ignored in tabular mode). */
+    setSimpleModePageTitle(title: string | null, routeKey: string): void;
+    private syncDocumentTitle;
+    private resolveTabularRouteTitle;
+    private resolveSimpleRouteTitle;
+    private resolveMenuRouteTitle;
+    private resolveApplicationTitle;
+    private resolveLocalizedText;
+    private buildDocumentTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBrowserTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPBrowserTitleService>;
+}
+
+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, formatterRegistry: AXFormatterRegistryService);
+    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",
+    HighlightAfterCreateInList = "Common:Setting:Entity.HighlightAfterCreateInList",
+    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",
+    NavigationMode = "Common:Setting:Navigation.Mode",
+    MaxOpenTabs = "Common:Setting:Navigation.MaxOpenTabs"
+}
+
+interface AXPSettingSetOptions {
+    /** When true, persist to remote immediately without debounce. */
+    flush?: boolean;
+}
+interface AXPSettingValueProvider {
+    get scope(): AXPPlatformScope;
+    load(): Promise<AXPSettingValue[]>;
+    set(key: string, value: any, options?: AXPSettingSetOptions): Promise<void>;
+    set(values: Record<string, any>, options?: AXPSettingSetOptions): Promise<void>;
+    /** Background refresh when local snapshot TTL expired or tab regains focus. */
+    revalidateIfNeeded?(): Promise<void>;
+    /** Force reload from local cache and remote. */
+    reload?(): 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;
+    /** When true, saving this setting from the settings page reloads the browser. */
+    requiresPageRefresh?: 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 AXPSettingsServiceInterface {
+    load(): Promise<AXPSettingValue[]>;
+    get<T = any>(key: string): Promise<T>;
+    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
+    scope(scope: AXPPlatformScope): ScopedSettingService;
+    reload(scope?: AXPPlatformScope): Promise<void>;
+}
+declare class AXPSettingsService implements AXPSettingsServiceInterface {
+    private readonly providers;
+    private readonly injector;
+    private readonly eventService;
+    private readonly sessionService;
+    private readonly debugService;
+    private readonly scopedSettingsCache;
+    private readonly scopeLoaded;
+    private loadInFlight;
+    private lastUserContextKey;
+    private lastTenantId;
+    readonly onChanged: Subject<AXPSettingChangedEvent>;
+    readonly onLoaded: ReplaySubject<void>;
+    constructor();
+    reload(scope?: AXPPlatformScope, reason?: string): Promise<void>;
+    ensureLoaded(): Promise<void>;
+    load(reason?: string): Promise<AXPSettingValue[]>;
+    private awaitSessionReady;
+    private doLoad;
+    /** Platform always; tenant when selected; user when authenticated with tenant. */
+    private shouldLoadProvider;
+    private requiredScopes;
+    private isScopeReady;
+    private isFullyLoaded;
+    private clearScopedCache;
+    /**
+     * 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>;
+    /**
+     * Inherited settings at tenant/user scope may match the definition default while still being an explicit
+     * override of a different parent value (e.g. tenant enables lock while platform default is disabled).
+     */
+    private isInheritedPlaceholder;
+    private resolveEffectiveAndDefault;
+    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
+    scope(scope: AXPPlatformScope): ScopedSettingService;
+    /** Applies remote values into the in-memory scope cache and notifies listeners. */
+    syncScopeCache(scope: AXPPlatformScope, values: Record<string, unknown>): void;
+    invokeChangeEvent(event: AXPSettingChangedEvent): void;
+    private applyDebugModeFromSettings;
+    private applyDebugModeFromEvent;
+    private isCachedInScopeOrAncestors;
+    private seedMissingDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsService>;
+}
+declare class ScopedSettingService {
+    private parent;
+    private provider;
+    private scopeCache;
+    private isScopeActive;
+    constructor(parent: AXPSettingsService, provider: AXPSettingValueProvider, scopeCache: Map<string, any>, isScopeActive: (scope: AXPPlatformScope) => boolean);
+    get<T = any>(key: string): Promise<T>;
+    all(): Promise<any>;
+    defaultValues(): Promise<Record<string, unknown>>;
+    set<T = any>(key: string, value: T, options?: AXPSettingSetOptions): Promise<void>;
+    set<T = any>(values: Record<string, T>, options?: AXPSettingSetOptions): Promise<void>;
+    update<T = any>(key: string, updateFn: (currentValue: T) => T): Promise<void>;
+}
+
+interface AXPEntityCreateListBehaviorOptions {
+    redirect?: boolean;
+}
+interface AXPEntityCreateListBehavior {
+    shouldRedirect: boolean;
+    shouldHighlight: boolean;
+}
+/**
+ * Resolves post-create list behavior from user settings and optional action overrides.
+ */
+declare function resolveEntityCreateListBehavior(settingsService: AXPSettingsService, options?: AXPEntityCreateListBehaviorOptions): Promise<AXPEntityCreateListBehavior>;
+
+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;
+
+interface AXPTranslateFormatterOptions extends AXFormatOptions {
+    scope?: string;
+    lang?: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * Platform formatter for display text: resolves ML objects, i18n keys (`@scope:key`), and primitives.
+ * Register via {@link AXPCommonModule} (auto) or `AXFormatModule.forRoot({ formatters: [AXPTranslateFormatter] })`.
+ */
+declare class AXPTranslateFormatter implements AXFormatter {
+    private readonly translationService;
+    get name(): string;
+    format(value: unknown, options?: AXPTranslateFormatterOptions | string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTranslateFormatter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTranslateFormatter>;
+}
+
+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>;
+    /** Download file bytes via the storage connector (includes auth when using API). */
+    abstract download(fileId: string): Promise<Blob>;
+    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 {
+    private readonly fileStorageService;
+    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
+}
+
+/** Strips the file-cast prefix and whitespace from a stored image reference. */
+declare function normalizeStoredImageRef(value: string | null | undefined): string | null;
+declare function isStoredImageFileId(value: string | null | undefined): boolean;
+declare function resolveStoredImageDisplayUrl(value: string, download: (fileId: string) => Promise<Blob>): Promise<string>;
+
+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 AXPIntegrationProviderContext {
+    private readonly definitions;
+    /**
+     * Registers a provider definition. Throws when duplicate ids are registered.
+     */
+    register(definition: AXPIntegrationProviderDefinition): void;
+    getDefinitions(): ReadonlyMap<string, AXPIntegrationProviderDefinition>;
+}
+
+interface AXPIntegrationProvider {
+    provide(context: AXPIntegrationProviderContext): Promise<void>;
+}
+declare const AXP_INTEGRATION_PROVIDER: InjectionToken<AXPIntegrationProvider[]>;
+interface AXPIntegrationRuntimeProvider {
+    readonly providerId: string;
+    getHooks(): Promise<_acorex_platform_framework_shared_core.AXPIntegrationProviderRuntimeHooks>;
+}
+declare const AXP_INTEGRATION_RUNTIME_PROVIDER: InjectionToken<AXPIntegrationRuntimeProvider[]>;
+
+declare class AXPIntegrationProviderRegistryService {
+    private readonly providers;
+    private cache;
+    list(): Promise<AXPIntegrationProviderDefinition[]>;
+    get(id: string): Promise<AXPIntegrationProviderDefinition | null>;
+    getOrThrow(id: string): Promise<AXPIntegrationProviderDefinition>;
+    clearCache(): void;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPIntegrationProviderRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPIntegrationProviderRegistryService>;
+}
+
+interface AXPIntegrationSecretRefInput {
+    providerId: string;
+    connectionId: string;
+    tenantId: string;
+    userId: string;
+    authMethodType: string;
+}
+interface AXPIntegrationSecretStore {
+    store(ref: AXPIntegrationSecretRefInput, payload: AXPIntegrationSecretPayload): Promise<string>;
+    rotate(secretRef: string, context: AXPIntegrationAuthContext, payload: Partial<AXPIntegrationSecretPayload>): Promise<void>;
+    resolve(secretRef: string, context: AXPIntegrationAuthContext): Promise<AXPIntegrationResolvedCredentials>;
+    revoke(secretRef: string, context: AXPIntegrationAuthContext): Promise<void>;
+    delete(secretRef: string, context: AXPIntegrationAuthContext): Promise<void>;
+}
+declare const AXP_INTEGRATION_SECRET_STORE: InjectionToken<AXPIntegrationSecretStore>;
+interface AXPIntegrationWithClientOptions {
+    providerId: string;
+    connectionScope?: 'user' | 'tenant';
+    connectionKey?: string;
+    requiredCapabilities?: string[];
+    requiredScopes?: string[];
+}
+declare abstract class AXPIntegrationRuntimeService {
+    abstract getProvider(id: string): Promise<AXPIntegrationProviderDefinition>;
+    abstract listProviders(): Promise<AXPIntegrationProviderDefinition[]>;
+    abstract getConnection(options: AXPIntegrationWithClientOptions): Promise<_acorex_platform_framework_shared_core.AXPSafeIntegrationConnectionDto>;
+    abstract withClient<T>(options: AXPIntegrationWithClientOptions, fn: (client: unknown, ctx: AXPIntegrationRuntimeContext) => Promise<T>): Promise<T>;
+    abstract buildRuntimeContext(connection: _acorex_platform_framework_shared_core.AXPSafeIntegrationConnectionDto & {
+        secretRef: string;
+    }): Promise<AXPIntegrationRuntimeContext>;
+}
+interface AXPIntegrationOAuthStartInput {
+    providerId: string;
+    connectionScope: 'user' | 'tenant';
+    connectionKey: string;
+    displayName: string;
+    redirectUri: string;
+    tenantId: string;
+    userId: string;
+    scopes?: string[];
+}
+interface AXPIntegrationOAuthCompleteInput {
+    providerId: string;
+    state: string;
+    code: string;
+}
+declare abstract class AXPIntegrationOAuthService {
+    abstract startAuthorization(input: AXPIntegrationOAuthStartInput): Promise<{
+        redirectUrl: string;
+        state: string;
+    }>;
+    abstract completeCallback(input: AXPIntegrationOAuthCompleteInput): Promise<{
+        connectionId: string;
+    }>;
+}
+declare const AXP_INTEGRATION_OAUTH_SERVICE: InjectionToken<AXPIntegrationOAuthService>;
+
+/**
+ * Optional hook invoked after a connection is successfully established (OAuth callback or credentials connect).
+ * Use to link provider-specific records (e.g. Jira/GitLab instance ↔ integration connection).
+ */
+interface AXPIntegrationConnectionEstablishedHandler {
+    readonly providerId: string;
+    onEstablished(connection: AXPSafeIntegrationConnectionDto): Promise<void>;
+}
+declare const AXP_INTEGRATION_CONNECTION_ESTABLISHED: InjectionToken<AXPIntegrationConnectionEstablishedHandler[]>;
+
+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;
+}
+
+/**
+ * Optional hook to resolve entity search definitions on demand (e.g. Module.X.Entity).
+ */
+interface AXPSearchDefinitionLazyResolver {
+    resolve(definitionName: string): Promise<AXPSearchDefinition | null>;
+}
+declare const AXP_SEARCH_DEFINITION_LAZY_RESOLVER: InjectionToken<AXPSearchDefinitionLazyResolver>;
+
+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 lazyResolver;
+    private cache;
+    private load;
+    getListAsync(): Promise<AXPSearchDefinition[]>;
+    getList(): AXPSearchDefinition[];
+    findDefinition(definitionName: string): AXPSearchDefinition;
+    findDefinitionAsync(definitionName: string): Promise<AXPSearchDefinition | null>;
+    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;
+    private contextEvalFactory;
+    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 display-tier row scope for entity title/search templates. */
+declare function createEntityRowExpressionScope(data: unknown, contextEvalFactory: AXPContextEvalFactory): AXPExpressionEvaluatorScope;
+/**
+ * Evaluates a normalized entity display template via {@link AXPExpressionEvaluatorService}.
+ */
+declare function evaluateEntityDisplayTemplate(template: string, data: unknown, expressionEvaluator: AXPExpressionEvaluatorService, locale: string, translationService: AXTranslationService, contextEvalFactory: AXPContextEvalFactory): 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, contextEvalFactory: AXPContextEvalFactory): Promise<AXPMultiLanguageString>;
+
+/**
+ * Modify/edit popup chrome: `{action} {individual} ({update.title ?? single.title})` when a record template exists.
+ */
+declare function resolveEntityModifyPopupTitle(entity: AXPEntity, recordData: unknown, translationService: AXTranslationService, formatService: AXFormatService, expressionEvaluator: AXPExpressionEvaluatorService, contextEvalFactory: AXPContextEvalFactory, actionTitleKey?: string): Promise<string>;
+/**
+ * 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, contextEvalFactory: AXPContextEvalFactory): 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;
+}
+/** 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/framework-client/layout/widget-core` does not import `@acorex-platform/framework-client/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;
+        requiresPageRefresh?: boolean;
+        defaultValue?: unknown;
+        valueTransforms?: AXPValueTransformerFunctions;
+        validationRules?: AXPValidationRules;
+    }): this;
+    endSection(): AXPSettingDefinitionGroupBuilder;
+}
+
+interface AXPSettingDefinitionProvider {
+    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
+}
+declare const AXP_SETTING_DEFINITION_PROVIDER: InjectionToken<AXPSettingDefinitionProvider[]>;
+declare class AXPSettingDefinitionProviderService {
+    private providers;
+    private cache;
+    private load;
+    reload(): Promise<void>;
+    getListAsync(scope: AXPPlatformScopeKey): Promise<AXPSettingDefinitionGroup[]>;
+    getList(scope: AXPPlatformScopeKey): AXPSettingDefinitionGroup[];
+    defaultValues(): Promise<Record<string, unknown>>;
+    settingScopeByKey(): Promise<Record<string, AXPPlatformScope>>;
+    settingInheritedByKey(): Promise<Record<string, boolean>>;
+    requiresPageRefreshByKey(): Promise<Record<string, boolean>>;
+    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 function createIndexedDbSettingValueProviders(injector: Injector): AXPSettingValueProvider[];
+declare const AXP_SETTING_VALUE_PROVIDER: InjectionToken<AXPSettingValueProvider[]>;
+declare function createDefaultSettingValueProviders(injector: Injector): 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;
+
+/**
+ * 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>;
+}
+
+/** How long a local snapshot is considered fresh before background revalidation. */
+declare const AXP_SETTINGS_SYNC_TTL_MS: Record<AXPPlatformScope, number>;
+/** Trailing debounce before bulk PATCH for incremental UI saves (theme resize, etc.). */
+declare const AXP_SETTINGS_SYNC_DEBOUNCE_MS: number;
+/** Silent retry backoff steps (ms); last value repeats. */
+declare const AXP_SETTINGS_SYNC_RETRY_BACKOFF_MS: readonly [2000, 5000, 15000, 60000];
+
+type AXPSettingsSyncStatus = 'idle' | 'syncing' | 'pending_retry';
+interface AXPScopedSettingsSnapshot {
+    id: string;
+    scope: AXPPlatformScope;
+    values: Record<string, unknown>;
+    serverUpdatedAt: string | null;
+    lastRevalidatedAt: string | null;
+    dirty: Record<string, unknown>;
+    syncStatus: AXPSettingsSyncStatus;
+    nextRetryAt: string | null;
+    retryAttempt: number;
+}
+interface AXPSettingsScopedFetchInput {
+    scope: AXPPlatformScope;
+    since: string | null;
+}
+interface AXPSettingsScopedPatchInput {
+    scope: AXPPlatformScope;
+    values: Record<string, unknown>;
+}
+interface AXPSettingsBulkFetchResult {
+    changed: boolean;
+    updatedAt: string | null;
+    values: Record<string, unknown>;
+}
+interface AXPSettingsBulkPatchResult {
+    updatedAt: string;
+}
+
+/** Debug namespace for all settings diagnostics. Filter console with `[AXP:Settings]`. */
+declare const SETTINGS_TRACE_NS = "Settings";
+declare const SETTINGS_TRACE_TITLE: {
+    /** AXPSettingsService in-memory cache (load, reload, ensureLoaded). */
+    readonly Cache: "Cache";
+    /** IndexedDB scoped snapshot provider (hydrate, debounce, flush). */
+    readonly LocalSnapshot: "LocalSnapshot";
+    /** Query/command bulk sync — counts as a server request. */
+    readonly ServerSync: "ServerSync";
+    /** AXPAppStartUpService settings task on app boot. */
+    readonly Startup: "Startup";
+    /** Settings page route + view model. */
+    readonly Page: "Page";
+    /** Dev-only client storage tools (export / import / reset). */
+    readonly ClientTools: "ClientTools";
+};
+
+/** Query/command keys for scoped settings bulk sync; provided by settings-management connectivity wiring. */
+interface AXPSettingsSyncKeys {
+    scopedFetchQueryKey: string;
+    scopedPatchCommandKey: string;
+}
+declare const AXP_SETTINGS_SYNC_KEYS: InjectionToken<AXPSettingsSyncKeys>;
+
+declare class AXPSettingsBulkSyncService {
+    private readonly queryService;
+    private readonly commandService;
+    private readonly syncKeys;
+    fetch(scope: AXPPlatformScope, since: string | null): Promise<AXPSettingsBulkFetchResult>;
+    patch(scope: AXPPlatformScope, values: Record<string, unknown>): Promise<AXPSettingsBulkPatchResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsBulkSyncService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsBulkSyncService>;
+}
+
+/** Emitted immediately after values are written to the scoped IndexedDB snapshot. */
+declare function traceSettingsLocalPersist(scope: AXPPlatformScope, payload: {
+    snapshotId: string;
+    keys: string[];
+    dirtyKeyCount: number;
+    flush: boolean;
+}): void;
+/** Emitted once per bulk query/command call. Count these for server request frequency. */
+declare function traceSettingsServerApiCall(method: 'GET' | 'PATCH', scope: AXPPlatformScope, payload: Record<string, unknown>): void;
+declare function traceSettingsFlush(scope: AXPPlatformScope, payload: {
+    snapshotId: string;
+    keys: string[];
+}): void;
+declare function traceSettingsSyncFailed(scope: AXPPlatformScope, payload: {
+    snapshotId: string;
+    keys: string[];
+    attempt: number;
+}): void;
+declare function traceSettingsRetryScheduled(scope: AXPPlatformScope, payload: {
+    snapshotId: string;
+    attempt: number;
+    backoffMs: number;
+    nextRetryAt: string;
+}): void;
+declare function traceSettingsRevalidateFailed(scope: AXPPlatformScope, payload: {
+    snapshotId: string;
+    since: string | null;
+}): void;
+declare function traceSettingsAppStartupLoadStarted(): void;
+declare function traceSettingsAppStartupLoadComplete(payload: {
+    totalKeys: number;
+    keysByScope: Record<string, number>;
+    durationMs: number;
+}): void;
+declare function traceSettingsServiceLoadStarted(reason: string): void;
+declare function traceSettingsServiceLoadComplete(payload: {
+    totalKeys: number;
+    keysByScope: Record<string, number>;
+    durationMs: number;
+}): void;
+declare function traceSettingsServiceReload(scope: AXPPlatformScope | 'all', reason: string): void;
+declare function traceSettingsServiceLoadFailed(error: unknown): void;
+declare function traceSettingsPageLoadStarted(scope: string, reason: string): void;
+declare function traceSettingsPageLoadComplete(payload: {
+    scope: string;
+    groupCount: number;
+    valueKeyCount: number;
+    durationMs: number;
+}): void;
+declare function traceSettingsPageRouteLoad(scope: string, reason: string): void;
+declare function traceSettingsClientTool(command: 'export' | 'import' | 'reset', message: string, payload?: Record<string, unknown>): void;
+
+declare class AXPSettingsIndexedDb extends Dexie {
+    scoped_snapshots: Table<AXPScopedSettingsSnapshot, string>;
+    constructor();
+}
+declare const axpSettingsIndexedDb: AXPSettingsIndexedDb;
+declare function buildScopedSettingsSnapshotId(scope: AXPPlatformScope, contextKey: string): string;
+declare function createEmptyScopedSettingsSnapshot(id: string, scope: AXPPlatformScope): AXPScopedSettingsSnapshot;
+
+declare class AXPIndexedDbSettingValueProvider implements AXPSettingValueProvider {
+    private readonly _scope;
+    private readonly injector;
+    private readonly sessionService;
+    private readonly bulkSync;
+    private contextKey;
+    private snapshotId;
+    private snapshot;
+    private hydrated;
+    private hydratePromise;
+    private debounceTimer;
+    private retryTimer;
+    private flushInFlight;
+    private revalidateInFlight;
+    constructor(_scope: AXPPlatformScope, injector: Injector);
+    private bindSessionContextChanges;
+    get scope(): AXPPlatformScope;
+    load(): Promise<AXPSettingValue[]>;
+    set(key: string, value: unknown, options?: AXPSettingSetOptions): Promise<void>;
+    set(values: Record<string, unknown>, options?: AXPSettingSetOptions): Promise<void>;
+    reload(): Promise<void>;
+    revalidateIfNeeded(): Promise<void>;
+    private hydrateFromIndexedDb;
+    private resetHydration;
+    private resolveContextKey;
+    private unbindSessionContext;
+    /**
+     * Binds snapshot id from restored session data. Only resets hydration when the scoped context changes
+     * (e.g. user switch), not when auth status re-emits for the same tenant/user.
+     */
+    private tryBindSessionContext;
+    private applyLocalPatch;
+    private persistSnapshot;
+    private persistSnapshotRecord;
+    private toSettingValues;
+    private shouldRevalidate;
+    private revalidateNow;
+    private resolveFetchSince;
+    private doRevalidate;
+    private scheduleDebouncedFlush;
+    flushNow(): Promise<void>;
+    private doFlush;
+    private scheduleSilentRetry;
+    private scheduleRetryIfDue;
+}
+
+interface AXPSettingsCacheSync {
+    syncScopeCache(scope: AXPPlatformScope, values: Record<string, unknown>): void;
+}
+declare const AXP_SETTINGS_CACHE_SYNC: InjectionToken<AXPSettingsCacheSync>;
+
+/**
+ * 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>;
+}
+
+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>;
+
+/**
+ * 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>;
+}
+
+/**
+ * Builds a stable tab key from a router URL.
+ * Path segments define identity; query params are excluded so the same entity record
+ * or list reuses one tab even when filters or refresh tokens change.
+ */
+declare function axpBuildTabKey(url: string): string;
+/** Normalizes a router URL for storage and navigation. */
+declare function normalizeRouterUrl(url: string): string;
+/** Human-readable fallback title from the URL path. */
+declare function axpFallbackTabTitle(url: string): string;
+
+type AXPNavigationMode = 'simple' | 'tabular';
+declare const AXP_HOME_TAB_KEY = "axp:home";
+/** Route `data` key for tab-navigation behavior (`data.tab`). */
+declare const AXP_TAB_ROUTE_DATA_KEY = "tab";
+/**
+ * Set `data.tab = true` on the route that should act as the tab boundary.
+ * Child navigations under this route update the same tab rather than opening a new one.
+ */
+type AXPTabRouteData = true;
+interface AXPTabDescriptor {
+    /** Stable dedupe key derived from the route (path-based, query excluded). */
+    key: string;
+    /** Full router URL including query string and fragment. */
+    url: string;
+    title: string;
+    /** Resolved breadcrumb segments used for tab chrome (leaf/prefix); avoids parsing joined titles. */
+    titleSegments?: string[];
+    icon?: string;
+    pinned: boolean;
+    closable: boolean;
+    /** Timestamp used for LRU eviction when max tabs is reached. */
+    openedAt: number;
+    /** Updated whenever the tab becomes active. */
+    lastActivatedAt: number;
+}
+interface AXPTabSessionState {
+    tabs: AXPTabDescriptor[];
+    activeTabKey: string | null;
+}
+/** Optional hook for confirming closure of a cached background tab (no router navigation). */
+interface AXPTabCloseConfirm {
+    onBeforeTabClose(): boolean | Promise<boolean>;
+}
+
+declare class AXPTabNavigationService {
+    private readonly router;
+    private readonly settingsService;
+    private readonly deviceService;
+    private readonly menuService;
+    private readonly homePageService;
+    private readonly sessionService;
+    private readonly routeCacheRegistry;
+    private readonly tabPreviewService;
+    private readonly unsavedChangesConfirm;
+    private readonly destroyRef;
+    private readonly navigationMode;
+    private readonly maxOpenTabs;
+    private readonly tabs;
+    private readonly activeTabKey;
+    private suppressNavigationSync;
+    /** Effective mode: mobile always uses simple navigation. */
+    readonly effectiveMode: i0.Signal<AXPNavigationMode>;
+    readonly isTabBarVisible: i0.Signal<boolean>;
+    readonly tabList: i0.Signal<AXPTabDescriptor[]>;
+    readonly activeKey: i0.Signal<string | null>;
+    constructor();
+    /** Navigates to a path, opening or activating a tab when tabular mode is active. */
+    navigate(path: string, extras?: NavigationExtras): Promise<boolean>;
+    /** Opens a tab or activates an existing tab with the same key. */
+    openOrActivateTab(url: string, title?: string): Promise<void>;
+    /**
+     * Activates a tab and navigates to its URL. The previously active page is detached and cached by
+     * the reuse strategy, so its state is preserved; this tab's cached instance is reattached when
+     * available instead of being re-rendered.
+     *
+     * @param suspendDeactivateGuard When true (default for tab switches), unsaved-changes prompts are
+     * skipped so switching tabs keeps a dirty page alive. Closing a tab passes false to keep the prompt.
+     */
+    activateTabKey(key: string, urlOverride?: string, suspendDeactivateGuard?: boolean): Promise<void>;
+    /** Closes a tab and navigates to a neighbor when the active tab is closed. */
+    closeTab(key: string): Promise<void>;
+    /** Closes every closable tab except the given key (pinned tabs are kept). */
+    closeOtherTabs(keepKey: string): Promise<void>;
+    /** Closes all closable tabs (pinned tabs are kept). */
+    closeAllTabs(): Promise<void>;
+    /** Toggles whether a tab stays pinned in the strip (home tab is always pinned). */
+    toggleTabPinned(key: string): void;
+    /**
+     * Reorders tabs after drag-and-drop. Home stays first; pinned and unpinned tabs cannot cross groups.
+     */
+    reorderTabs(previousIndex: number, currentIndex: number): void;
+    /** Updates a tab title from the current page chrome (e.g. breadcrumb trail). */
+    syncTabTitle(key: string, titleOrSegments: string | string[]): void;
+    /** Updates a tab icon from the current page chrome or menu metadata. */
+    syncTabIcon(key: string, icon: string): void;
+    /** Closes multiple tabs in one update; navigates once when the active tab is closed. */
+    private closeTabs;
+    /**
+     * Prompts before closing a cached background tab. Uses the page's {@link AXPTabCloseConfirm}
+     * hook when available, otherwise falls back to the tab preview dirty flag.
+     */
+    private confirmBackgroundTabClose;
+    /**
+     * Navigates away from the active tab before it is removed so canDeactivate runs while the tab is still visible.
+     * Returns false when navigation was cancelled (e.g. unsaved-changes confirmation declined).
+     */
+    private navigateAwayBeforeClosingActiveTab;
+    /** Prefers the tab to the right after removal, then the tab to the left (browser-like). */
+    private resolveFallbackTabIndex;
+    /**
+     * Keeps the route cache registry aligned with the current navigation mode and the set of open
+     * tabs. Cached page instances for closed/evicted tabs are destroyed by the registry.
+     */
+    private bindRouteCacheSync;
+    private bindRouterEvents;
+    private handleNavigationEnd;
+    private loadSettings;
+    private bindSettingsChanges;
+    private bindSessionChanges;
+    private ensureHomeTab;
+    private insertTab;
+    /** Home first; preserves session order for the remaining tabs. */
+    private ensureHomeTabFirst;
+    private getLastPinnedTabIndex;
+    /** Home first, then other pinned tabs, then unpinned tabs (stable by openedAt within each group). */
+    private normalizeTabOrder;
+    private enforceMaxTabs;
+    private createTabDescriptor;
+    /** Finds a tab by scoped key or legacy full-path key for the same URL. */
+    private findTabForUrl;
+    /** True when the URL is the configured application home page (e.g. dashboard). */
+    private isHomePageUrl;
+    private resolveHomeUrl;
+    /** Activates the pinned home tab for a home-page URL instead of opening a duplicate tab. */
+    private activateHomeTabForUrl;
+    /** Drops non-home tabs that duplicate the home page URL after session restore. */
+    private removeDuplicateHomeUrlTabs;
+    /** Rewrites a tab key when route-scope resolution changes (e.g. profile sub-routes). */
+    private migrateTabKey;
+    /** Collapses restored tabs that share the same scoped route key. */
+    private normalizeRestoredTabKeys;
+    private updateTabUrl;
+    private updateTabTitle;
+    private updateTabIcon;
+    private touchTab;
+    private resolveTabTitle;
+    private resolveTabIcon;
+    private resolveHomePath;
+    private resolveHomeTitle;
+    private isGenericHomeTitle;
+    private syncCurrentRouteAsTab;
+    private normalizeMaxTabs;
+    private sessionStorageKey;
+    private persistSession;
+    private clearSession;
+    private restoreSessionIfNeeded;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTabNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTabNavigationService>;
+}
+
+/** Structured hover-card payload for a tab (kept in memory; not session-persisted). */
+interface AXPTabStructuredPreview {
+    /** Primary label (usually page title or breadcrumb trail). */
+    title: string;
+    /** Optional page description or secondary line. */
+    subtitle?: string;
+    /** Full router URL for the tab. */
+    url: string;
+    icon?: string;
+    /** Whether the cached page reports unsaved user edits. */
+    isDirty: boolean;
+    /** Breadcrumb segments excluding home (for the hover card). */
+    breadcrumbTrail: string[];
+}
+
+/**
+ * In-memory structured previews for tab hover cards and dirty indicators.
+ * Populated by active/cached pages via {@link AXPPageLayoutBaseComponent}.
+ */
+declare class AXPTabPreviewService {
+    private readonly previewMap;
+    readonly previews: i0.Signal<Readonly<Record<string, AXPTabStructuredPreview>>>;
+    setPreview(key: string, preview: AXPTabStructuredPreview): void;
+    patchPreview(key: string, patch: Partial<AXPTabStructuredPreview>): void;
+    getPreview(key: string): AXPTabStructuredPreview | undefined;
+    isTabDirty(key: string): boolean;
+    clearPreview(key: string): void;
+    clearPreviews(keys: Iterable<string>): void;
+    clearAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTabPreviewService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTabPreviewService>;
+}
+
+/**
+ * Holds detached Angular route component instances keyed by tab key so tabular navigation can
+ * preserve a page's full state (data-table selection, scroll, unsaved form values, etc.) while it
+ * is in the background, then reattach it without re-rendering.
+ *
+ * The registry has no `Router` dependency on purpose: it is consumed by the {@link RouteReuseStrategy}
+ * implementation, so depending on `Router` here would create a construction-time cycle.
+ */
+declare class AXPTabRouteCacheRegistry {
+    private readonly handles;
+    private openKeys;
+    private enabled;
+    private deactivateGuardSuspended;
+    /**
+     * Runs `action` while unsaved-changes `canDeactivate` guards are suspended, so switching between
+     * tabs preserves a dirty page without prompting. Closing a tab does not use this path, so the
+     * prompt still appears there.
+     */
+    runWithSuspendedDeactivateGuards<T>(action: () => Promise<T>): Promise<T>;
+    isDeactivateGuardSuspended(): boolean;
+    /** Enables caching (tabular mode). Disabling clears and destroys every cached component. */
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    /**
+     * Reconciles open scoped tab keys and active tab URLs. Cached handles whose key is not an open
+     * scoped tab key, an active tab URL, or a child path under an open scoped tab are destroyed.
+     */
+    syncOpenKeys(scopedKeys: string[], activeTabUrls?: string[]): void;
+    isOpen(key: string): boolean;
+    /**
+     * Returns the live component instance for a cached background tab, when available.
+     * Matches the tab key directly or any cached handle under a scoped tab prefix.
+     */
+    getComponentInstance<T>(key: string): T | null;
+    /**
+     * Caches a detached background handle. Overwrites without destroying the previous handle: on a
+     * repeat visit Angular hands back a new handle object wrapping the same live `componentRef`, so
+     * destroying the old one would destroy the live component and corrupt the view (NG0922).
+     */
+    store(key: string, handle: DetachedRouteHandle): void;
+    /**
+     * Returns the cached handle without mutating the map. Angular reads a handle twice per
+     * navigation (once while building the future state, once while attaching), so `retrieve` must be
+     * idempotent; the handle is released afterwards via {@link release} when Angular calls
+     * `store(snapshot, null)`.
+     */
+    retrieve(key: string): DetachedRouteHandle | null;
+    /**
+     * Drops a handle that the router has just reattached (it is now a live foreground view, so it
+     * must not be destroyed). The map keeps only truly backgrounded handles.
+     */
+    release(key: string): void;
+    has(key: string): boolean;
+    /** Destroys and removes a single cached handle (used when a tab closes). */
+    evict(key: string): void;
+    /** Destroys and removes every cached handle. */
+    clear(): void;
+    private readComponentInstance;
+    private destroyHandle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTabRouteCacheRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTabRouteCacheRegistry>;
+}
+
+/**
+ * Returns true when the URL represents an in-app page that may appear in the tab bar.
+ */
+declare function axpIsTabEligibleUrl(url: string): boolean;
+
+/** True when the route declares itself as a scoped tab root (`data.tab = true`). */
+declare function axpHasTabScope(data: Record<string, unknown> | undefined): boolean;
+/** Resolved URL path for a snapshot (no query or fragment). */
+declare function axpPathFromSnapshot(snapshot: ActivatedRouteSnapshot): string;
+/** Returns the leaf snapshot under the router state root. */
+declare function axpGetLeafRouteSnapshot(root: ActivatedRouteSnapshot): ActivatedRouteSnapshot;
+/**
+ * Resolves the tab dedupe key from an activated route tree.
+ * Uses the nearest ancestor with `data.tab = true`; otherwise the leaf path.
+ */
+declare function axpResolveTabKeyFromSnapshot(leaf: ActivatedRouteSnapshot): string;
+/**
+ * Resolves a tab key for the given URL (or the current router URL).
+ * Prefers the live route snapshot when it matches the target URL; otherwise matches route config.
+ */
+declare function axpResolveTabKey(router: Router, url?: string): string;
+/**
+ * Matches a URL path against registered routes and resolves the tab key from `data.tab`.
+ */
+declare function axpResolveTabKeyFromRouteConfig(routes: Routes, pathOnly: string): string | null;
+
+declare const AXP_TAB_BREADCRUMB_JOIN_SEPARATOR = " - ";
+interface AXPTabTitleParts {
+    prefix: string | null;
+    leaf: string;
+}
+/** Joins breadcrumb segments for the stored tab title and tooltip full label. */
+declare function axpJoinTabTitleSegments(segments: string[]): string;
+/** Derives compact tab label parts from structured breadcrumb segments. */
+declare function axpResolveTabTitleParts(tab: {
+    titleSegments?: string[];
+}, fallbackTitle: string): AXPTabTitleParts;
+
+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>;
+}
+
+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;
+    private tabNavigation;
+    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>;
+}
+
+/** Workflow event type dispatched after a successful entity delete. */
+declare const AXP_ENTITY_DELETED_WORKFLOW_EVENT_TYPE = "[Entity] Deleted";
+interface AXPEntityDeletedEventPayload {
+    entity: string;
+    ids: string[];
+    meta?: unknown;
+}
+
+declare class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
+    private readonly tabNavigation;
+    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, AXPBrowserTitleService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPIndexedDbSettingValueProvider, AXPIntegrationOAuthService, AXPIntegrationProviderContext, AXPIntegrationProviderRegistryService, AXPIntegrationRuntimeService, AXPKeyboardShortcutsHelpComponent, AXPKeyboardShortcutsHelpService, AXPLockService, AXPMenuItemsDataSourceDefinition, AXPMenuKeyboardShortcutService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuRouteAccessService, AXPMenuRouteGuard, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPNotFoundCatchAllRoute, AXPNotFoundError, AXPOutputContractTranscriptSegmentService, AXPPlatformCommonDataSourceKeys, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalCalendarService, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsBulkSyncService, AXPSettingsEvaluatorScopeProvider, AXPSettingsIndexedDb, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStickyDirective, AXPTabNavigationService, AXPTabPreviewService, AXPTabRouteCacheRegistry, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPTranslateFormatter, 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_ENTITY_DELETED_WORKFLOW_EVENT_TYPE, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_HOME_TAB_KEY, AXP_INTEGRATION_CONNECTION_ESTABLISHED, AXP_INTEGRATION_OAUTH_SERVICE, AXP_INTEGRATION_PROVIDER, AXP_INTEGRATION_RUNTIME_PROVIDER, AXP_INTEGRATION_SECRET_STORE, 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_LAZY_RESOLVER, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTINGS_CACHE_SYNC, AXP_SETTINGS_SYNC_DEBOUNCE_MS, AXP_SETTINGS_SYNC_KEYS, AXP_SETTINGS_SYNC_RETRY_BACKOFF_MS, AXP_SETTINGS_SYNC_TTL_MS, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TAB_BREADCRUMB_JOIN_SEPARATOR, AXP_TAB_ROUTE_DATA_KEY, 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, 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, SETTINGS_TRACE_NS, SETTINGS_TRACE_TITLE, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, axpBackgroundOperationCapabilities, axpBackgroundOperationDisplayTime, axpBackgroundOperationEntityName, axpBackgroundOperationEstimateEndDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationFromEntityModel, axpBackgroundOperationRemainingMs, axpBackgroundOperationToEntityModel, axpBuildBackgroundOperation, axpBuildTabKey, axpCoerceBackgroundOperationDate, axpCreateBackgroundOperationId, axpFallbackTabTitle, axpFindMenuItemByRoute, axpGetLeafRouteSnapshot, axpHasTabScope, axpIsActiveBackgroundOperationStatus, axpIsCompletedBackgroundOperationStatus, axpIsEntityDetailsPath, axpIsEntityDetailsViewRoute, axpIsEntityListPath, axpIsEntityListRoute, axpIsEntityRecordNotFound, axpIsTabEligibleUrl, axpJoinTabTitleSegments, axpMenuPathsMatch, axpNavigateAppPath, axpParseAppPath, axpPathFromSnapshot, axpRedirectToNotFound, axpRedirectToUnauthorized, axpReplaceEntityListRouteQueryParams, axpResolveTabKey, axpResolveTabKeyFromRouteConfig, axpResolveTabKeyFromSnapshot, axpResolveTabTitleParts, axpSettingsIndexedDb, backgroundOperationEntityFactory, buildScopedSettingsSnapshotId, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createBackgroundOperationStore, createDefaultSettingValueProviders, createEmptyScopedSettingsSnapshot, createEntityCommandOptions, createEntityRowExpressionScope, createEntitySearchCommand, createIndexedDbSettingValueProviders, createMenuContext, createMenuMiddleware, createUnsavedChangesCanDeactivateGuard, downloadGraphicFromElement, evaluateEntityDisplayTemplate, findManualPresetIdByOperation, formatEntityRowDisplayTitle, inferSettingCoercionKind, isStoredImageFileId, normalizePositiveNumberOption, normalizeRouterUrl, normalizeStoredImageRef, peelSettingValueKey, printGraphicFromElement, provideDynamicHomePage, provideMenuMiddleware, resolveDateFilterPresets, resolveEntityCreateListBehavior, resolveEntityModifyPopupTitle, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle, resolveEntityRowDisplayTitleFromColumnContext, resolveEntitySearchTitleFallback, resolveGraphicElementSize, resolveGraphicPrintContent, resolveQueryMatchingDisplayText, resolveSearchDisplayTemplate, resolveSearchableText, resolveStoredImageDisplayUrl, searchInRecordValues, searchInSearchableValue, serializeSvgElement, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, traceSettingsAppStartupLoadComplete, traceSettingsAppStartupLoadStarted, traceSettingsClientTool, traceSettingsFlush, traceSettingsLocalPersist, traceSettingsPageLoadComplete, traceSettingsPageLoadStarted, traceSettingsPageRouteLoad, traceSettingsRetryScheduled, traceSettingsRevalidateFailed, traceSettingsServerApiCall, traceSettingsServiceLoadComplete, traceSettingsServiceLoadFailed, traceSettingsServiceLoadStarted, traceSettingsServiceReload, traceSettingsSyncFailed, triggerBrowserDownload, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
+export type { AXCFileUploaderAction, AXCFileUploaderActionsPayload, AXCFileUploaderCapabilities, AXPAgentOutputContract, AXPAgentResponseFormat, AXPAppPathParts, AXPAppVersion, AXPAppVersionProvider, AXPBackgroundOperation, AXPBackgroundOperationActionKey, AXPBackgroundOperationCapabilities, AXPBackgroundOperationCreateRequest, AXPBackgroundOperationEntityModel, AXPBackgroundOperationEntityStorageAdapter, AXPBackgroundOperationError, AXPBackgroundOperationFailureMode, AXPBackgroundOperationFailurePolicy, AXPBackgroundOperationProviderStore, AXPBackgroundOperationStatus, AXPCommonModuleConfigs, AXPCurrency, AXPDateTimeFilterPreset, AXPDateTimeFilterPresetKind, AXPDateTimeFilterValue, AXPDomToImageOptions, AXPEntityCreateListBehavior, AXPEntityCreateListBehaviorOptions, AXPEntityDeletedEventPayload, AXPErrorHandler, AXPFileActionProvider, AXPFileActionProviderToken, AXPFileExtension, AXPFileType, AXPFileTypeInfoProvider, AXPFilterOperator, AXPGeoLocation, AXPGraphicDownloadFormat, AXPGraphicDownloadOptions, AXPGraphicPrintContent, AXPGroupSearchResult, AXPHomePageDefinition, AXPInAppNotificationCreateRequest, AXPInAppNotificationPriority, AXPInAppNotificationService, AXPIntegrationConnectionEstablishedHandler, AXPIntegrationOAuthCompleteInput, AXPIntegrationOAuthStartInput, AXPIntegrationProvider, AXPIntegrationRuntimeProvider, AXPIntegrationSecretRefInput, AXPIntegrationSecretStore, AXPIntegrationWithClientOptions, AXPJsonSchemaLike, AXPLanguage, AXPLocaleManagementPort, AXPLocaleProfile, AXPLockGetInfoRequest, AXPLockInfo, AXPLockRequest, AXPLockType, AXPMenuFinderResult, AXPMenuInsertion, AXPMenuItem, AXPMenuItemCommand, AXPMenuItemFinder, AXPMenuItemWithParent, AXPMenuMiddleware, AXPMenuMiddlewareContext, AXPMenuMiddlewareProvider, AXPMenuProvider, AXPMenuProviderContext, AXPMenuRouteMatchResult, AXPMenuType, AXPNavigationMode, AXPOutputContractTranscriptSegmentDefinition, AXPOutputContractTranscriptSegmentProvider, AXPOutputContractTranscriptSegmentProviderToken, AXPPlatformConfigs, AXPPrintGraphicOptions, AXPResolveEntityRowDisplayTitleOptions, AXPRootConfigs, AXPScopedSettingsSnapshot, AXPSearchAction, AXPSearchDefinition, AXPSearchDefinitionDisplayFormat, AXPSearchDefinitionLazyResolver, AXPSearchDefinitionProvider, AXPSearchDisplayGroupResult, AXPSearchDisplayResult, AXPSearchDisplayResultForSave, AXPSearchParentResult, AXPSearchProvider, AXPSearchResult, AXPSettingChangedEvent, AXPSettingCoercionKind, AXPSettingDefaultValuesProvider, AXPSettingDefinition, AXPSettingDefinitionGroup, AXPSettingDefinitionProvider, AXPSettingDefinitionSection, AXPSettingLayoutOptions, AXPSettingMergedDefaults, AXPSettingSetOptions, AXPSettingValue, AXPSettingValueProvider, AXPSettingsBulkFetchResult, AXPSettingsBulkPatchResult, AXPSettingsCacheSync, AXPSettingsScopedFetchInput, AXPSettingsScopedPatchInput, AXPSettingsServiceInterface, AXPSettingsSyncKeys, AXPSettingsSyncStatus, AXPTabCloseConfirm, AXPTabDescriptor, AXPTabRouteData, AXPTabSessionState, AXPTabStructuredPreview, AXPTabTitleParts, AXPTimeZone, AXPTokenDefinition, AXPTokenDefinitionProvider, AXPTokenDefinitionProviderToken, AXPTranslateFormatterOptions, AXPUnLockRequest, AXPUnsavedChangesCanDeactivate, AXPUnsavedChangesConfirmOptions, AXPUnsavedChangesPopstateSource, AXPVersionChange, AXPVersionEntry, AXPVersionStream, CanonicalChange, CanonicalChangeOp, VersionedFileInfo };