import * as i0 from '@angular/core';
import { InjectionToken, EnvironmentProviders, Injector, ErrorHandler, ModuleWithProviders, EventEmitter, ElementRef, Renderer2, NgZone, ChangeDetectorRef } from '@angular/core';
import { AXStyleColorType, AXDataSourceOperator, AXDataSourceFilterOption } from '@acorex/cdk/common';
import * as i2 from '@acorex/components/popup';
import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
import * as i5 from '@acorex/platform/core';
import { AXPValueTransformerFunctions, AXPGridLayoutOptions, AXPValidationRules, AXPSystemActionType, AXPMetaData, AXPOptionsData, AXPLogoConfig, AXPFileListItem, AXPNavigateActionCommand, AXPExecuteCommand, AXPEntityReference, AXPApplicationUserReference, AXPPlatformScopeKey, AXPPlatformScope, AXPWidgetTriggers, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext } from '@acorex/platform/core';
import { AXPWidgetTypesMap, AXPMetaDataDefinition, AXPWidgetNode } from '@acorex/platform/layout/widget-core';
import * as i6 from '@angular/router';
import { Route, Routes } from '@angular/router';
import * as i1 from '@acorex/platform/workflow';
import { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflow } from '@acorex/platform/workflow';
import * as i3 from '@acorex/core/date-time';
import * as i4 from '@acorex/components/toast';
import * as rxjs from 'rxjs';
import { Subject } from 'rxjs';
import * as _ngrx_signals from '@ngrx/signals';
import { AXTranslationService } from '@acorex/core/translation';
import { AXLocaleProfile } from '@acorex/core/locale';

interface AXPAppVersion {
    version: string;
    build: number;
    date: Date;
}
interface AXPAppVersionProvider {
    provider(): Promise<AXPAppVersion>;
}
declare const AXP_APP_VERSION_PROVIDER: InjectionToken<AXPAppVersionProvider>;
declare class AXPAppVersionService {
    private provider;
    getAppVersion(): Promise<AXPAppVersion>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAppVersionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPAppVersionService>;
}

interface AXEntityPropertyWidget {
    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
    path?: string;
    id?: string;
    formula?: string;
    children?: AXEntityPropertyWidget[];
    mode: 'view' | 'edit';
    options?: Record<string, any>;
    triggers?: {
        event: string;
        action: string;
        disabled?: boolean;
    }[];
    valueTransforms?: AXPValueTransformerFunctions;
}
declare enum AXPRelationshipKind {
    Association = 0,
    Composition = 1,
    Aggregation = 2
}
declare enum AXPRelationshipCardinality {
    OneToOne = 0,
    OneToMany = 1,
    ManyToMany = 2
}
interface AXPRelationship {
    id: string;
    from: string;
    to: string;
    kind: AXPRelationshipKind;
    cardinality: AXPRelationshipCardinality;
}
declare enum AXPEntityCommandScope {
    TypeLevel = "typeLevel",
    Selected = "selected",
    Individual = "individual",
    Section = "section"
}
declare enum AXPEntityQueryType {
    Single = "single",
    List = "list"
}
interface AXPEntityPropertyLayoutConfig extends AXPGridLayoutOptions {
    label?: {
        visible?: boolean;
    };
    order?: number;
}
interface AXPEntityPropertyGroup {
    id: string;
    title: string;
    description?: string;
    permissions?: string[];
    icon?: string;
}
interface AXPEntityPropertyView {
    name: string;
    dataPath?: string;
    permissions?: string[];
    layout?: AXPEntityPropertyLayoutConfig;
}
interface AXPEntityPropertyUpdateView extends AXPEntityPropertyView {
}
interface AXPEntityPropertyCreateView extends AXPEntityPropertyView {
    defaultValue?: any;
}
interface AXPEntitySectionView {
    id: string;
    order?: number;
    collapsed?: boolean;
    layout?: AXPEntityPropertyLayoutConfig;
}
interface AXPEntityProperty {
    name: string;
    title: string;
    description?: string;
    groupId?: string;
    schema: {
        dataType: string;
        nullable?: boolean;
        readonly?: boolean | string;
        visible?: boolean | string;
        defaultValue?: any | string | ((context: any | null) => any);
        unique?: {
            enabled: boolean;
        };
        interface?: Partial<AXEntityPropertyWidget>;
    };
    options?: {
        filter?: {
            advance?: {
                enabled?: boolean;
                widgetType?: AXPWidgetTypesMap[keyof AXPWidgetTypesMap];
            };
            inline?: {
                enabled?: boolean;
            };
        };
        sort?: {
            enabled?: boolean;
        };
    };
    validations?: AXPValidationRules;
}
interface AXPEntityTableColumn {
    name: string;
    title?: string;
    hidden?: boolean;
    showAs?: {
        type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
        options?: Record<string, any>;
    };
    sort?: {
        enabled?: boolean;
        dir?: 'asc' | 'desc';
    };
    options?: {
        visible?: boolean;
        width?: string;
        dataPath?: string;
        [name: string]: any;
    };
}
interface AXPEntityCommand {
    execute: string | Function;
    permissions?: string[];
}
interface AXPEntityQuery {
    execute: string | Function;
    type: AXPEntityQueryType;
}

type AXPCommandActionType = AXPSystemActionType;
interface AXPCommandActionLook {
    color: AXStyleColorType;
    icon: string;
}
type AXPCommandActionPriority = 'primary' | 'secondary';
type AXPCommandActionCallback = string | {
    name: string;
    options?: {
        decoration?: {
            header?: {
                title?: string;
            };
        };
        process?: {
            data?: any;
            [name: string]: any;
        };
        layout?: {
            size?: AXPopupSizeType;
        };
        [name: string]: any;
    };
    metadata?: AXPMetaData;
};
interface AXPCommandActionDisplay extends Partial<AXPCommandActionLook> {
    name?: string;
    command: AXPCommandActionCallback;
    title: string;
    type: AXPSystemActionType | string;
    priority: 'primary' | 'secondary';
    separated?: boolean;
    permissions?: string[];
    hidden?: boolean | string;
    disabled?: boolean | string;
    default?: boolean;
    order?: number;
}
interface AXPEntityAction extends AXPCommandActionDisplay {
    scope: AXPEntityCommandScope;
}
interface AXPEntity {
    plugins?: {
        name: string;
        options?: AXPOptionsData;
    }[];
    module: string;
    name: string;
    icon?: string;
    parentKey?: string;
    category?: AXPCategoryEntity;
    title: string;
    formats: {
        individual: string;
        plural: string;
        lookup?: string;
        displayName?: string;
        searchResult?: {
            title: string;
            description?: string;
        };
    };
    relatedEntities?: AXPRelatedEntity[];
    groups?: AXPEntityPropertyGroup[];
    properties: AXPEntityProperty[];
    columns?: AXPEntityTableColumn[];
    commands?: {
        create?: AXPEntityCommand | undefined;
        update?: AXPEntityCommand | undefined;
        delete?: AXPEntityCommand | undefined;
        [name: string]: AXPEntityCommand | undefined;
    };
    queries?: {
        byKey?: AXPEntityQuery;
        list?: AXPEntityQuery;
        lookup?: AXPEntityQuery;
        history?: AXPEntityQuery;
        comments?: AXPEntityQuery;
        [name: string]: AXPEntityQuery | undefined;
    };
    validations?: AXPValidationRules;
    interfaces?: {
        master?: {
            single?: AXPEntityMasterSingleLayoutView;
            list?: AXPEntityMasterListView;
            create?: AXPEntityMasterCreateLayoutView;
            update?: AXPEntityMasterUpdateLayoutView;
        };
        detail?: {
            list?: AXPEntityDetailListView;
        };
    };
}
declare function getEntityInfo(entity: AXPEntity): {
    source: string;
    module: {
        route: string;
    };
    entity: {
        route: string;
    };
};
declare function createQueryView(name: string, title: string, fixed: boolean, params?: {
    columns?: string[];
    conditions?: any[];
    sorts?: AXPQuerySort[];
}): AXPQueryView;
declare function createAllQueryView(params?: {
    columns?: string[];
    conditions?: AXPQueryFilter[];
    sorts?: AXPQuerySort[];
} | undefined): AXPQueryView;
interface AXPRelatedEntity {
    entity: string;
    title?: string;
    icon?: string;
    columns?: string[];
    layout?: {
        type: 'tab-detail' | 'tab-list' | 'page-detail' | 'page-list' | 'merge-detail';
        order?: number;
        position?: 'before' | 'after' | 'middle';
    };
    conditions?: AXPQueryFilter[];
    hidden?: boolean | string;
    actions?: AXPEntityAction[];
    /**
     * Relationship-level persistence strategy for merge-detail data.
     * Defaults:
     * - strategy: 'embedded'
     * - idField: last segment of dataPath + 'Id' (or 'relatedId' when dataPath is missing)
     * - map: undefined (pass-through)
     * - hydrate: 'eager' (applies to getOne only in mock)
     * - cascade.delete: 'none'
     */
    persistence?: {
        strategy?: 'embedded' | 'referenced';
        idField?: string;
        dataPath?: string;
        map?: Record<string, string>;
        hydrate?: 'eager' | 'lazy';
        cascade?: {
            delete?: 'none' | 'orphans' | 'all';
        };
    };
}
interface AXPCategoryEntity {
    entity: string;
    title?: string;
    textField?: string;
    valueField?: string;
    conditions?: AXPQueryFilter[];
    applyConditions?: AXPQueryFilter[];
}
interface AXPEntityVersionHistory {
    enabled?: boolean;
    showInList?: boolean;
    showInDetail?: boolean;
}
interface AXPAggregate {
    id: string;
    name: string;
    title: string;
    entities: AXPEntity[];
}
interface AXPModule {
    name: string;
    title: string;
    aggregates: AXPAggregate[];
    relationships?: AXPRelationship[];
}
interface AXPApplication {
    name: string;
    title: string;
    modules: AXPModule[];
}
interface AXPEntityMasterLayoutView {
    title?: string;
    sections: AXPEntitySectionView[];
    properties?: AXPEntityPropertyView[];
}
interface AXPEntityMasterCreateLayoutView extends AXPEntityMasterLayoutView {
    steps?: {
        id: string;
        title: string;
        description?: string;
    };
}
interface AXPEntityMasterUpdateLayoutView extends AXPEntityMasterLayoutView {
}
interface AXPEntityMasterSingleLayoutView extends AXPEntityMasterLayoutView {
    title: string;
    description?: string;
    actions?: AXPEntityAction[];
}
interface AXPEntityMasterListView {
    title?: string;
    description?: string;
    actions?: AXPEntityAction[];
    views: AXPQueryView[];
    layouts?: {
        table?: {
            columns: AXPEntityTableColumn[];
        };
        card?: {};
    };
}
interface AXPEntityDetailListView {
    title?: string;
    description?: string;
    columns: AXPEntityTableColumn[];
    actions?: AXPEntityAction[];
}
interface AXPQueryView {
    name: string;
    fixed: boolean;
    title: string;
    columns: string[];
    conditions: AXPQueryFilter[];
    sorts: AXPQuerySort[];
    indexCol?: boolean;
    pageSize?: number;
    visible?: boolean;
}
interface AXPQueryFilter {
    name: string;
    operator: AXDataSourceOperator;
    value: any;
}
interface AXPQuerySort {
    name: string;
    dir: 'asc' | 'desc';
}

interface AXPFilterOperator {
    name: string;
    title: string;
    hasValue: boolean;
}
declare const EQ_OPER: AXPFilterOperator;
declare const NOT_EQ_OPER: AXPFilterOperator;
declare const GT_OPER: AXPFilterOperator;
declare const LT_OPER: AXPFilterOperator;
declare const GTE_OPER: AXPFilterOperator;
declare const LTE_OPER: AXPFilterOperator;
declare const CONTAINS_OPER: AXPFilterOperator;
declare const NOT_CONTAINS_OPER: AXPFilterOperator;
declare const IN_OPER: AXPFilterOperator;
declare const STARTS_WITH_OPER: AXPFilterOperator;
declare const ENDS_WITH_OPER: AXPFilterOperator;
declare const IS_EMPTY_OPER: AXPFilterOperator;
declare const IS_NOT_EMPTY_OPER: AXPFilterOperator;
declare const BETWEEN_OPER: AXPFilterOperator;
declare const STRING_OPERATORS: AXPFilterOperator[];
declare const NUMBER_OPERATORS: AXPFilterOperator[];
declare const BOOLEAN_OPERATORS: AXPFilterOperator[];
declare const DATE_OPERATORS: AXPFilterOperator[];
declare const ALL_DEFAULT_OPERATORS: AXPFilterOperator[];

interface AXPHomePageDefinition {
    key: string;
    title: string;
    route: Route;
}
declare const AXP_HOME_PAGES: InjectionToken<AXPHomePageDefinition[]>;
declare const AXP_HOME_PAGE_DEFAULT_KEY: InjectionToken<string>;

declare function provideDynamicHomePage(): EnvironmentProviders;

declare class AXPHomePageService {
    private defaultHomePageKey;
    private userHomePageKey;
    private candidates;
    private settingsService;
    private sessionService;
    private injector;
    private originalConfig;
    private loginPath;
    private get flatCandidates();
    constructor();
    private init;
    load(): Promise<void>;
    getRegisteredList(): AXPHomePageDefinition[];
    getRegisteredRoutes(): Routes;
    getCurrent(): {
        path: string;
        title: string;
    };
    private findPath;
    private buildFullPaths;
    private refreshRoutes;
    private applyMergedConfig;
    navigateTo(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPHomePageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPHomePageService>;
}

declare class AXPHomePageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPHomePageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPHomePageModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXPHomePageModule>;
}

interface AXPErrorHandler {
    handleError(error: Error, next: (error: Error) => void): void;
}

declare class AXPErrorHandlerRegistryService {
    private injector;
    private errorHandlers;
    constructor(injector: Injector);
    register(...plugins: (new () => AXPErrorHandler)[]): void;
    get handlers(): AXPErrorHandler[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPErrorHandlerRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPErrorHandlerRegistryService>;
}

declare class AXPGlobalErrorHandler extends ErrorHandler {
    private injector;
    private registry;
    constructor(injector: Injector, registry: AXPErrorHandlerRegistryService);
    handleError(error: Error): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPGlobalErrorHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPGlobalErrorHandler>;
}

interface AXPCommonModuleConfigs {
    errorHandlers: (new () => AXPErrorHandler)[];
}
declare class AXPCommonModule {
    static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
    static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
    /**
     * @ignore
     */
    constructor(instances: any[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPCommonModule, never, [typeof i1.AXPWorkflowModule, typeof i2.AXPopupModule, typeof i3.AXDateTimeModule, typeof i4.AXToastModule, typeof i5.AXPModuleManifestModule], [typeof i6.RouterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXPCommonModule>;
}

declare const ENVIRONMENT: InjectionToken<any>;
declare const AXP_PLATFORM_CONFIG_TOKEN: InjectionToken<AXPPlatformConfigs>;
interface AXPPlatformConfigs {
    title?: string;
    copyright?: string;
    logo?: {
        icon: {
            light: AXPLogoConfig;
            dark: AXPLogoConfig;
        };
        text: {
            light: AXPLogoConfig;
            dark: AXPLogoConfig;
        };
        full: {
            light: AXPLogoConfig;
            dark: AXPLogoConfig;
        };
    };
    network?: {
        timeOut?: number;
    };
}
declare const AXPPlatformDefaultConfigs: AXPPlatformConfigs;
declare function configPlatform(config?: Partial<AXPPlatformConfigs>): AXPPlatformConfigs;

declare enum AXPCommonSettings {
    EnableOperationToasts = "Common:Setting:Notifications.EnableOperationToasts",
    EntityFilterApplyMode = "Common:Setting:Entity.FilterApplyMode"
}

declare const AXP_ROOT_CONFIG_TOKEN: InjectionToken<AXPRootConfigs>;
interface AXPRootConfigs {
    baseUrl: string;
}

declare abstract class AXPDataProvider {
    abstract insertOne(entity: any, entityItem: any): Promise<any>;
    abstract insertMany(entity: any, entityList: any): Promise<any>;
    abstract getOne(entity: any, id: string): Promise<any>;
    abstract getMany(entity: any, params?: any): Promise<any>;
    abstract updateOne(entity: any, id?: string, data?: {
        [key: string]: any;
    }): Promise<any>;
    abstract deleteOne(entity: any, id: string): Promise<any>;
    abstract getFirst(entity: any): Promise<any>;
    abstract uploadFile(file: File, title: string, customUrl?: string): Promise<string>;
    abstract updateFile(id: string, file: File, title: string, customUrl?: string): Promise<string>;
    abstract uploadMultipleFiles(files: File[], title: string): Promise<string[]>;
    abstract viewFile(id: string, name: string): Promise<Blob>;
    abstract downloadFile(id: string, name: string): Promise<Blob>;
}

declare abstract class AXPFilterOperatorMiddlewareService {
    /**
     * Middleware to transform selected filters into corresponding operators.
     * @param filters Array of selected filters (e.g., user input).
     * @param customOperators Optional custom operators map to override default operators.
     * @returns Transformed filters based on custom or default operators.
     */
    abstract transformFilters(filters: AXDataSourceFilterOption[]): AXDataSourceFilterOption[];
    /**
     * Helper method to transform a single filter. This handles recursion for nested filters.
     * @param filter A single filter object.
     * @returns Transformed filter.
     */
    abstract transformFilter(filters: AXDataSourceFilterOption): AXDataSourceFilterOption;
    abstract getOperator(key: string): AXDataSourceOperator;
}
declare class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddlewareService {
    private customOperatorService;
    private operators;
    transformFilters(filters: AXDataSourceFilterOption[]): AXDataSourceFilterOption[];
    transformFilter(filter: AXDataSourceFilterOption): AXDataSourceFilterOption;
    getOperator(key: string): AXDataSourceOperator;
    private getDefaultOperators;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFilterOperatorMiddlewareServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFilterOperatorMiddlewareServiceImpl>;
}

declare abstract class AXPCustomOperatorService {
    abstract getCustomOperators(): {
        [key: string]: AXDataSourceOperator;
    };
}
declare class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
    getCustomOperators(): {
        [key: string]: AXDataSourceOperator;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCustomOperatorServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCustomOperatorServiceImpl>;
}

declare enum AXPFileStorageStatus {
    Temporary = "temporary",// File is not yet associated with a parent entity
    Committed = "committed",// File is fully associated and in use
    PendingDeletion = "pendingDeletion",// File is marked for deletion but not yet removed
    Archived = "archived",// File is archived and no longer actively used
    Error = "error"
}
/**
 * Interface representing a file storage request in the Acorex platform.
 */
interface AXPFileStorageCreateRequest {
    /**
     * The file to be stored.
     */
    file: File;
    /**
     * The name of the file.
     */
    name?: string;
    /**
     * The unique identifier of referenced entity.
     */
    refId: string;
    /**
     * The type of the referenced entity.
     */
    refType: string;
    /**
     * The category of the file. profile-picture, company-logo, policy, document, etc.
     */
    category: string;
    /**
     * The folder path where the file should be stored.
     * If null, the service will resolve the path based on metadata, user, tenant, or default rules.
     */
    path?: string;
    /**
     * Metadata associated with the file.
     */
    metadata?: AXPMetaData;
    /**
     * Indicates whether the file is primary or not.
     */
    isPrimary?: boolean;
    /**
     * Indicates the status of the file.
     */
    status?: AXPFileStorageStatus;
}
interface AXPFileStorageUpdateRequest {
    /**
     * The unique identifier for the stored file.
     */
    fileId: string;
    /**
     * The folder path where the file should be stored.
     * If null, the service will resolve the path based on metadata, user, tenant, or default rules.
     */
    path?: string;
    /**
     * The name of the file.
     */
    name?: string;
    /**
     * Metadata associated with the file.
     */
    metadata: AXPMetaData;
    /**
     * Indicates whether the file is primary or not.
     */
    isPrimary?: boolean;
}
interface AXPFileManyStorageInfo {
    /**
    * The unique identifier for the stored file.
    */
    id?: string;
    /**
     * The unique identifier for the stored file.
     */
    fileId: string;
    /**
    * The unique identifier of referenced entity.
    */
    refId: string;
    /**
     * The type of the referenced entity.
     */
    refType: string;
    /**
     * The size of the file in bytes.
     */
    size: number;
    /**
     * The name of the file.
     */
    name?: string;
}
/**
 * Represents information about a file stored in the AXP file storage system.
 */
interface AXPFileStorageInfo {
    /**
     * The unique identifier for the stored file.
     */
    id?: string;
    /**
     * The unique identifier for the stored file.
     */
    fileId: string;
    /**
     * The unique identifier of referenced entity.
     */
    refId: string;
    /**
     * The type of the referenced entity.
     */
    refType: string;
    /**
     * The category of the file. profile-picture, company-logo, policy, document, etc.
     */
    category: string;
    /**
     * The URL where the file can be accessed.
     */
    url?: string;
    /**
     * The size of the file in bytes.
     */
    size: number;
    /**
     * The name of the file.
     */
    name?: string;
    /**
     * The MIME type of the file.
     */
    mimeType: string;
    /**
     * The date and time when the file was uploaded.
     */
    uploadedAt: Date;
    /**
     * Indicates whether the file is public or private.
     */
    isPublic: boolean;
    /**
     * Indicates whether the file is primary or not.
     */
    isPrimary?: boolean;
    status: AXPFileStorageStatus;
    binary: File;
}
interface AXPFileStorageInfo {
    /**
     * The unique identifier for the stored file.
     */
    id?: string;
    /**
     * The unique identifier for the stored file.
     */
    fileId: string;
    /**
     * The unique identifier of referenced entity.
     */
    refId: string;
    /**
     * The type of the referenced entity.
     */
    refType: string;
    /**
     * The category of the file. profile-picture, company-logo, policy, document, etc.
     */
    category: string;
    /**
     * The URL where the file can be accessed.
     */
    url?: string;
    /**
     * The size of the file in bytes.
     */
    size: number;
    /**
     * The name of the file.
     */
    name?: string;
    /**
     * The MIME type of the file.
     */
    mimeType: string;
    /**
     * The date and time when the file was uploaded.
     */
    uploadedAt: Date;
    /**
     * Indicates whether the file is public or private.
     */
    isPublic: boolean;
    /**
     * Indicates whether the file is primary or not.
     */
    isPrimary?: boolean;
    status: AXPFileStorageStatus;
    binary: File;
}
/**
 * Represents information about a file stored in the AXP file storage system.
 */
interface AXPFileStorageFindRequest {
    /**
     * The unique identifier of referenced entity.
     */
    refId?: string;
    /**
     * The type of the referenced entity.
     */
    refType?: string;
    /**
     * The category of the file. profile-picture, company-logo, policy, document, etc.
     */
    category?: string;
    /**
     * The MIME type of the file.
     */
    mimeType?: string;
    /**
     * Indicates whether the file is public or private.
     */
    isPublic?: boolean;
    /**
     * Indicates whether the file is primary or not.
     */
    isPrimary?: boolean;
    /**
     * The date and time range when the file was uploaded.
     */
    uploadedAtRange?: {
        from: Date;
        to: Date;
    };
}

declare abstract class AXPFileStorageService {
    abstract save(request: AXPFileStorageCreateRequest): Promise<AXPFileStorageInfo>;
    abstract update(request: AXPFileStorageUpdateRequest): Promise<AXPFileStorageInfo>;
    abstract find(request: AXPFileStorageFindRequest): Promise<AXPFileStorageInfo[]>;
    abstract findMany(ids: string[]): Promise<AXPFileManyStorageInfo[]>;
    abstract getInfo(fileId: string): Promise<AXPFileStorageInfo>;
    abstract remove(fileId: string): Promise<void>;
    abstract commit(fileId: string): Promise<void>;
    abstract markForDeletion(fileId: string): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFileStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFileStorageService>;
}

/**
 * Capabilities API provided to file action providers.
 * These methods allow actions to interact with the file uploader widget.
 */
interface AXCFileUploaderCapabilities {
    /**
     * Get all current files in the uploader.
     */
    getFiles: () => AXPFileListItem[];
    /**
     * Replace all files in the uploader.
     */
    setFiles: (files: AXPFileListItem[]) => void;
    /**
     * Add new files to the uploader.
     */
    addFiles: (files: AXPFileListItem[]) => void;
    /**
     * Update files matching a predicate.
     */
    updateFile: (predicate: (f: AXPFileListItem) => boolean, updater: (f: AXPFileListItem) => AXPFileListItem) => void;
    /**
     * Remove a file from the uploader.
     */
    removeFile: (file: AXPFileListItem) => void;
    /**
     * Clear all files from the uploader.
     */
    clear: () => void;
    /**
     * Get a file by its ID.
     */
    getFileById: (id: string) => AXPFileListItem | undefined;
    /**
     * Update a file by its ID.
     */
    updateFileById: (id: string, next: Partial<AXPFileListItem>) => void;
}
/**
 * A file uploader action that can be added by providers.
 */
interface AXCFileUploaderAction {
    /**
     * Unique identifier for the action/plugin.
     */
    plugin: string;
    /**
     * Whether this action is global (available even if plugin is not explicitly enabled).
     */
    global?: boolean;
    /**
     * Display text for the action (optional if textKey is provided).
     */
    text?: string;
    /**
     * Translation key for the action text (optional if text is provided).
     */
    textKey?: string;
    /**
     * Icon class for the action (e.g., 'fa-light fa-file-arrow-up').
     */
    icon?: string;
    /**
     * Action execution handler.
     * Receives capabilities to interact with the file uploader.
     * @param capabilities The capabilities API for file operations.
     */
    run: (capabilities: AXCFileUploaderCapabilities) => void | Promise<void>;
}
/**
 * Payload passed to file action providers.
 */
interface AXCFileUploaderActionsPayload {
    /**
     * Enabled plugins configuration.
     */
    plugins: {
        name: string;
        options?: unknown;
    }[];
    /**
     * List of plugin names to exclude.
     */
    excludePlugins: string[];
    /**
     * Capabilities API for interacting with the file uploader.
     */
    capabilities: AXCFileUploaderCapabilities;
    /**
     * Current list of actions (providers can add to this array).
     */
    actions: AXCFileUploaderAction[];
    /**
     * Widget options (optional, for accessing widget-specific settings).
     */
    options?: {
        /**
         * Whether multiple files are allowed.
         */
        multiple?: boolean;
        /**
         * Accepted file types (e.g., '.jpg,.png' or 'image/*').
         */
        accept?: string;
    };
}

/**
 * Type for file action provider token (supports both direct and async providers).
 */
type AXPFileActionProviderToken = AXPFileActionProvider | Promise<AXPFileActionProvider>;
/**
 * File action provider interface.
 * Providers can add actions to the file uploader widget.
 */
interface AXPFileActionProvider {
    /**
     * Unique key identifying this provider.
     * Should match the webhook key for backward compatibility: 'file-uploader.actions'
     */
    key: string;
    /**
     * Execute the provider to add actions.
     * @param payload The payload containing capabilities and current actions.
     * @returns The modified payload with new actions added.
     */
    execute(payload: AXCFileUploaderActionsPayload): Promise<AXCFileUploaderActionsPayload> | AXCFileUploaderActionsPayload;
    /**
     * Priority for execution order (lower numbers execute first).
     * Defaults to 0 if not specified.
     */
    priority?: number;
}
/**
 * Multi-provider injection token for file action providers.
 * Modules can provide multiple implementations using this token.
 */
declare const AXP_FILE_ACTION_PROVIDER: InjectionToken<AXPFileActionProviderToken[]>;

/**
 * Service for managing file uploader actions.
 * Aggregates actions from multiple providers and filters them based on plugin configuration.
 * Wraps the hook system for backward compatibility.
 */
declare class AXPFileActionsService {
    private readonly actionProviders;
    private readonly hookService;
    private readonly injector;
    /**
     * Get all actions from providers, filtered based on plugin configuration.
     * Wraps the hook system for backward compatibility.
     * @param payload Initial payload with capabilities and plugin configuration.
     * @returns Filtered list of actions.
     */
    getActions(payload: AXCFileUploaderActionsPayload): Promise<AXCFileUploaderAction[]>;
    /**
     * Resolve all providers (handle both direct providers and Promise<provider>).
     */
    private resolveProviders;
    /**
     * Filter actions based on enabled plugins and exclude list.
     */
    private filterActions;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFileActionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFileActionsService>;
}

declare const UploadFromComputerActionProvider: AXPFileActionProvider;

interface AXPFileType {
    /**
     * The unique identifier for the file type.
     */
    /**
     * The name unique of the file type.
     */
    name: string;
    /**
     * The title of the file type.
     */
    title: string;
    /**
     * The description of the file type.
     */
    description?: string;
    extensions: AXPFileExtension[];
    /**
     * The icon of the file type.
     */
    icon?: string;
    /**
     * The metadata associated with the file type.
     */
    meta?: AXPMetaDataDefinition[];
}
interface AXPFileExtension {
    /**
     * The unique identifier for the file extension.
     */
    /**
     * The name unique of the file extension.
     */
    name: string;
    /**
     * The title of the file extension.
     */
    title: string;
    /**
     * The description of the file extension.
     */
    description?: string;
    /**
    * The icon of the file type.
    */
    icon?: string;
    /**
     * The color of the file type.
     */
    color?: string;
    /**
     * The metadata associated with the file extension.
     */
    meta?: AXPMetaDataDefinition[];
}

interface AXPFileTypeInfoProvider {
    items(): Promise<AXPFileType[]>;
}
declare const AXP_FILE_TYPE_INFO_PROVIDER: InjectionToken<AXPFileTypeInfoProvider[]>;
declare class AXPFileTypeProviderService implements AXPFileTypeInfoProvider {
    private providers;
    items(): Promise<AXPFileType[]>;
    get(name: string): Promise<AXPFileType | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFileTypeProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPFileTypeProviderService>;
}

declare class AXPStickyDirective {
    private element;
    private renderer;
    private zone;
    private cdr;
    stickyClass: string;
    stickyOffset: number;
    isStickyChange: EventEmitter<boolean>;
    private _isSticky;
    get isSticky(): boolean;
    set isSticky(value: boolean);
    private topOffset;
    private parentElement;
    private targetElement;
    private mutationObserver;
    stickyParent: string | HTMLElement;
    stickyTarget: string;
    constructor(element: ElementRef<HTMLDivElement>, renderer: Renderer2, zone: NgZone, cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    private initSticky;
    private updateTopOffset;
    private onParentScroll;
    private toggleStickyClasses;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPStickyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPStickyDirective, "[axpSticky]", ["axpSticky"], { "stickyClass": { "alias": "axpSticky"; "required": false; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; }; "stickyParent": { "alias": "stickyParent"; "required": false; }; "stickyTarget": { "alias": "stickyTarget"; "required": false; }; }, { "isStickyChange": "isStickyChange"; }, never, never, true, never>;
}

type AXPMenuInsertion = 'before' | 'after' | 'inside';
type AXPMenuType = 'menu' | 'group' | 'break';
type AXPMenuItemCommand = AXPNavigateActionCommand<'modal' | 'router'> | AXPExecuteCommand;
interface AXPMenuItem {
    text: string;
    type?: AXPMenuType;
    name?: string;
    description?: string;
    icon?: string;
    priority?: number;
    children?: AXPMenuItem[];
    path?: string;
    command?: AXPMenuItemCommand | undefined;
    badgeKey?: string;
    data?: any;
    meta?: AXPMetaData;
    policy?: {
        permissions?: string[];
        features?: string[];
    };
}
interface AXPMenuFinderResult {
    readonly exists: boolean;
    insert(items: AXPMenuItem[], position: AXPMenuInsertion): void;
    remove(): void;
    update(updatedItem: Partial<AXPMenuItem>): void;
    addItems(items: AXPMenuItem[]): void;
}
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;
    /**
     * 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;
    /**
     * Merge new item properties into existing item, handling children merge
     */
    private mergeMenuItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuProviderService>;
}

/**
 * Rich context API for manipulating menu items within middleware
 * Provides helper methods to find, update, remove, and add menu items easily
 */
interface AXPMenuMiddlewareContext {
    /**
     * Get all menu items
     */
    readonly items: AXPMenuItem[];
    /**
     * Find menu item(s) by name or pattern
     */
    find(nameOrPattern: string | RegExp): AXPMenuItemFinder;
    /**
     * Find menu item by name (exact match)
     */
    findByName(name: string): AXPMenuItemFinder;
    /**
     * Find menu items by pattern (regex or wildcard)
     */
    findByPattern(pattern: string | RegExp): AXPMenuItemFinder[];
    /**
     * Add new menu items to root level
     */
    add(...items: AXPMenuItem[]): AXPMenuMiddlewareContext;
    /**
     * Remove menu items by predicate
     */
    remove(predicate: (item: AXPMenuItem) => boolean): AXPMenuMiddlewareContext;
    /**
     * Sort all menu items recursively by priority
     */
    sort(): AXPMenuMiddlewareContext;
    /**
     * Get the final menu items array
     */
    toArray(): AXPMenuItem[];
}
/**
 * Helper for finding and manipulating a specific menu item
 */
interface AXPMenuItemFinder {
    /**
     * Get the found menu item (or undefined)
     */
    get(): AXPMenuItem | undefined;
    /**
     * Check if menu item exists
     */
    exists(): boolean;
    /**
     * Update menu item properties
     */
    update(updater: Partial<AXPMenuItem> | ((item: AXPMenuItem) => Partial<AXPMenuItem>)): AXPMenuItemFinder;
    /**
     * Remove the menu item
     */
    remove(): AXPMenuItemFinder;
    /**
     * Hide the menu item (removes it from the menu)
     */
    hide(): AXPMenuItemFinder;
    /**
     * Show the menu item (currently a no-op as items are visible by default)
     * Note: To truly implement show, we'd need to track removed items
     */
    show(): AXPMenuItemFinder;
    /**
     * Set priority
     */
    setPriority(priority: number): AXPMenuItemFinder;
    /**
     * Add children to this menu item
     */
    addChildren(...children: AXPMenuItem[]): AXPMenuItemFinder;
    /**
     * Remove children by predicate
     */
    removeChildren(predicate: (child: AXPMenuItem) => boolean): AXPMenuItemFinder;
    /**
     * Move menu item to a different parent
     */
    moveTo(parentName: string | null | undefined): AXPMenuItemFinder;
    /**
     * Insert menu items before this item
     */
    insertBefore(...items: AXPMenuItem[]): AXPMenuItemFinder;
    /**
     * Insert menu items after this item
     */
    insertAfter(...items: AXPMenuItem[]): AXPMenuItemFinder;
}
/**
 * Middleware that processes menu items after all providers have executed
 * Middlewares are executed in order based on their priority (higher priority = earlier execution)
 */
interface AXPMenuMiddleware {
    /**
     * Optional priority for execution order (higher = earlier)
     * Default: 0
     */
    readonly priority?: number;
    /**
     * Optional name for debugging and identification
     */
    readonly name?: string;
    /**
     * Process menu items using the rich context API
     * @param context - The menu middleware context with helper methods
     * @returns Processed context or void (context is mutable)
     */
    process(context: AXPMenuMiddlewareContext): Promise<void | AXPMenuMiddlewareContext>;
}
/**
 * Provider definition for registering middleware via multi-provider
 */
interface AXPMenuMiddlewareProvider {
    /**
     * The middleware instance
     */
    middleware: AXPMenuMiddleware;
    /**
     * Optional priority override
     */
    priority?: number;
}
/**
 * Injection token for menu middlewares (multi-provider)
 */
declare const AXP_MENU_MIDDLEWARE: InjectionToken<AXPMenuMiddleware[]>;

/**
 * Creates a rich context for menu manipulation
 * Similar to entity modifier context pattern
 */
declare function createMenuContext(items: AXPMenuItem[]): AXPMenuMiddlewareContext;

/**
 * Central service for managing menu middlewares with priority-based ordering
 * Similar to token registry pattern used in identifier-management
 */
declare class AXPMenuMiddlewareRegistry {
    /**
     * Manually registered middlewares
     */
    private readonly manualMiddlewares;
    /**
     * Provider-based middlewares (multi-provider injection)
     */
    private readonly providerMiddlewares;
    /**
     * Manually register a middleware
     * @param middleware - The middleware to register
     */
    register(middleware: AXPMenuMiddleware): void;
    /**
     * Unregister a middleware by name
     * @param name - The name of the middleware to remove
     */
    unregister(name: string): void;
    /**
     * Get a specific middleware by name
     * @param name - The middleware name
     */
    get(name: string): AXPMenuMiddleware | undefined;
    /**
     * Get all middlewares sorted by priority (highest first)
     * Combines provider-based and manually registered middlewares
     */
    list(): AXPMenuMiddleware[];
    /**
     * Check if a middleware exists
     * @param name - The middleware name
     */
    exists(name: string): boolean;
    /**
     * Clear all manually registered middlewares
     * Provider-based middlewares are not affected
     */
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuMiddlewareRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuMiddlewareRegistry>;
}

/**
 * Helper function to provide menu middlewares with proper DI setup
 * Similar to provideCommandMiddleware pattern
 *
 * @example
 * ```typescript
 * // In app.config.ts or module providers
 * export const appConfig: ApplicationConfig = {
 *   providers: [
 *     provideMenuMiddleware([
 *       customizationMiddleware,
 *       securityMiddleware,
 *       loggingMiddleware
 *     ])
 *   ]
 * };
 * ```
 */
declare function provideMenuMiddleware(middlewares: AXPMenuMiddleware[]): EnvironmentProviders;
/**
 * Helper to create a class-based middleware with priority
 *
 * @example
 * ```typescript
 * const myMiddleware = createMenuMiddleware({
 *   name: 'my-middleware',
 *   priority: 100,
 *   process: async (context) => {
 *     context.find('dashboard').setPriority(1);
 *   }
 * });
 * ```
 */
declare function createMenuMiddleware(config: {
    name: string;
    priority?: number;
    process: (context: AXPMenuMiddlewareContext) => Promise<void>;
}): AXPMenuMiddleware;

declare const AXPMenuService: i0.Type<{
    items: i0.Signal<AXPMenuItem[]>;
    selectedMenuItem: _ngrx_signals.DeepSignal<{
        item: AXPMenuItem | null;
        isFullMatch: boolean;
    }>;
    setMenuItems: (items: AXPMenuItem[]) => void;
    selectMenuItemByRoute: (path: string) => void;
    executeCommand: (item: AXPMenuItem) => void;
    isItemOpen: (item: AXPMenuItem) => boolean;
} & _ngrx_signals.StateSource<{
    items: AXPMenuItem[];
    selectedMenuItem: {
        item: AXPMenuItem | null;
        isFullMatch: boolean;
    };
}>>;

/**
 * Service for checking menu item visibility based on permissions, features, and children.
 * This service helps filter out empty menu items that have no visible children.
 */
declare class AXPMenuVisibilityService {
    private sessionService;
    /**
     * Checks if a menu item should be visible based on permissions and features.
     */
    isItemVisible(item: AXPMenuItem): boolean;
    /**
     * Recursively checks if a menu item has any visible children.
     * @param item The menu item to check
     * @param getRouterLink Optional function to check if an item has a router link
     */
    hasVisibleChildren(item: AXPMenuItem, getRouterLink?: (item: AXPMenuItem) => unknown): boolean;
    /**
     * Determines if a menu item should be rendered.
     * A menu item should be rendered if:
     * 1. It has a routerLink, OR
     * 2. It has visible children, OR
     * 3. It has a command (for non-router navigation)
     *
     * @param item The menu item to check
     * @param getRouterLink Optional function to check if an item has a router link
     */
    shouldRenderMenuItem(item: AXPMenuItem, getRouterLink?: (item: AXPMenuItem) => unknown): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuVisibilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuVisibilityService>;
}

interface AXPSearchDefinitionDisplayFormat {
    title?: string;
    description?: string;
    icon?: string;
    id?: string;
}
interface AXPSearchDefinition {
    name: string;
    title: string;
    group: string;
    icon: string;
    order: number;
    format: AXPSearchDefinitionDisplayFormat;
    actions: AXPSearchAction[];
}
interface AXPSearchParentResult {
    title: string;
    data?: any;
}
interface AXPSearchResult {
    id?: string;
    group: string;
    data?: any;
    title?: string;
    description?: string;
    icon?: string;
    command: AXPExecuteCommand;
    parent?: AXPSearchParentResult;
}
interface AXPSearchDisplayGroupResult {
    name: string;
    title: string;
    order: number;
    children: AXPSearchDisplayResult[];
}
interface AXPSearchDisplayResult {
    id: string;
    definitionName?: string;
    definitionTitle?: string;
    name: string;
    title: string;
    description?: string;
    icon: string;
    data?: any;
    order?: any;
    command: AXPExecuteCommand;
    parent?: AXPSearchParentResult;
    actions: AXPSearchAction[];
}
interface AXPSearchDisplayResultForSave {
    id: string;
    name: string;
    title: string;
    description?: string;
    icon: string;
    command: AXPExecuteCommand;
    parent?: {
        title: string;
        description?: string;
    };
}
interface AXPSearchAction extends Partial<AXPCommandActionLook> {
    name: string;
    type: AXPSystemActionType | string;
    priority: AXPCommandActionPriority;
    separated?: boolean;
}

declare class AXPSearchDefinitionProviderContext {
    private definitions;
    private definitionMap;
    addDefinition(name: string, title: string, group: string, icon: string, order: number, options?: {
        format?: AXPSearchDefinitionDisplayFormat;
        actions?: AXPSearchAction[];
    }): AXPSearchDefinitionBuilder;
    getDefinitions(): AXPSearchDefinition[];
    hasEntity(name: string): boolean;
    getDefinition(name: string): AXPSearchDefinition | undefined;
}
declare class AXPSearchDefinitionBuilder {
    private context;
    private definition;
    constructor(context: AXPSearchDefinitionProviderContext, definition: AXPSearchDefinition);
    addAction(name: string): AXPSearchDefinitionActionBuilder;
    action(name: string): AXPSearchDefinitionActionBuilder | null;
    endEntity(): AXPSearchDefinitionProviderContext;
}
declare class AXPSearchDefinitionActionBuilder {
    private entityBuilder;
    constructor(entityBuilder: AXPSearchDefinitionBuilder);
    endAction(): AXPSearchDefinitionBuilder;
}

interface AXPSearchDefinitionProvider {
    provide(context: AXPSearchDefinitionProviderContext): Promise<void>;
}
declare const AXP_SEARCH_DEFINITION_PROVIDER: InjectionToken<AXPSearchDefinitionProvider[]>;
declare class AXPSearchDefinitionProviderService {
    private providers;
    private cache;
    private load;
    getListAsync(): Promise<AXPSearchDefinition[]>;
    getList(): AXPSearchDefinition[];
    findDefinition(definitionName: string): AXPSearchDefinition;
    findDefinitionByGroup(definitionGroup: string): AXPSearchDefinition;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSearchDefinitionProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSearchDefinitionProviderService>;
}

interface AXPSearchProvider {
    search(text: string): Promise<AXPSearchResult[]>;
}
declare abstract class AXPSearchCommandProvider {
    abstract commands: AXPSearchResult[];
    search(text: string): Promise<AXPSearchResult[]>;
}

declare const AXP_SEARCH_PROVIDER: InjectionToken<AXPSearchProvider[]>;
declare class AXPSearchService {
    private providers;
    private definitionService;
    private formatService;
    search(text: string): Promise<AXPSearchDisplayGroupResult[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSearchService>;
}

declare class AXPMenuSearchDefinitionProvider implements AXPSearchDefinitionProvider {
    provide(context: AXPSearchDefinitionProviderContext): Promise<void>;
}

interface AXPMenuItemWithParent extends AXPMenuItem {
    parent?: AXPMenuItem;
}
declare class AXPMenuSearchProvider implements AXPSearchProvider {
    menuService: AXPMenuProviderService;
    translateService: AXTranslationService;
    search(text: string): Promise<AXPSearchResult[]>;
    /**
     * Recursively searches AXPMenuItem and its children for a matching text.
     *
     * @param menuItems - The array of AXPMenuItem to search in.
     * @param searchText - The text to search for (case-insensitive).
     * @returns An array of AXPMenuItem that match the search text.
     */
    private searchMenuItems;
}

declare class AXPFooterTextSlotComponent {
    text: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFooterTextSlotComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AXPFooterTextSlotComponent, "ng-component", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AXPNavBarSlotComponent {
    items: AXPMenuItem[];
    protected handleCommand(action?: AXPMenuItemCommand): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPNavBarSlotComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AXPNavBarSlotComponent, "ng-component", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
}

interface 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>;
}

interface AXPSettingValueProvider {
    get scope(): AXPPlatformScope;
    load(): Promise<AXPSettingValue[]>;
    set(key: string, value: any): Promise<void>;
    set(values: Record<string, any>): Promise<void>;
}
/**
 * Provider interface for supplying default setting values from higher layers (e.g., app, mocks, API).
 * Providers are merged by ascending priority; later providers override earlier values on key conflicts.
 */
interface AXPSettingDefaultValuesProvider {
    /** Merge order; lower numbers are applied first. Default is 0. */
    priority?: number;
    /** Returns a flat map of setting key to default value. */
    provide(): Promise<Record<string, unknown>>;
}
interface AXPSettingValue {
    key: string;
    value: any;
}
interface AXPSettingChangedEvent {
    scope: AXPPlatformScope;
    keys: string[];
    values: Record<string, any>;
    entries: AXPSettingValue[];
}
interface AXPSettingDefinition {
    name: string;
    title: string;
    description?: string;
    widget: AXPWidgetNode;
    layout?: AXPGridLayoutOptions;
    scope: AXPPlatformScopeKey;
    isRequired?: boolean;
    isInherited?: boolean;
    isEncrypted?: boolean;
    defaultValue?: unknown;
    value?: unknown;
}
interface AXPSettingDefinitionGroup {
    name: string;
    title: string;
    icon?: string;
    description?: string;
    groups: AXPSettingDefinitionGroup[];
    sections: AXPSettingDefinitionSection[];
}
interface AXPSettingDefinitionSection {
    name: string;
    title: string;
    description?: string;
    settings: AXPSettingDefinition[];
}
interface AXPGroupSearchResult {
    breadcrumb: {
        name: string;
        title: string;
        description?: string;
    }[];
    sections: AXPSettingDefinitionSection[] | null;
    groups: AXPSettingDefinitionGroup[] | null;
}

declare class AXPSettingDefinitionProviderContext {
    private rootGroups;
    private groupMap;
    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
    group(name: string): AXPSettingDefinitionGroupBuilder | null;
    getGroups(): AXPSettingDefinitionGroup[];
    hasGroup(name: string): boolean;
    getGroup(name: string): AXPSettingDefinitionGroup | undefined;
}
declare class AXPSettingDefinitionGroupBuilder {
    private context;
    private group;
    constructor(context: AXPSettingDefinitionProviderContext, group: AXPSettingDefinitionGroup);
    addSection(name: string, title: string, description?: string): AXPSettingDefinitionSectionBuilder;
    section(name: string): AXPSettingDefinitionSectionBuilder | null;
    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
    endGroup(): AXPSettingDefinitionProviderContext;
}
declare class AXPSettingDefinitionSectionBuilder {
    private groupBuilder;
    private section;
    constructor(groupBuilder: AXPSettingDefinitionGroupBuilder, section: AXPSettingDefinitionSection);
    addSetting(setting: {
        key: string;
        title: string;
        scope: AXPPlatformScopeKey;
        widget: {
            type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
            options?: AXPOptionsData;
            triggers?: AXPWidgetTriggers;
            layout?: AXPGridLayoutOptions;
        };
        description?: string;
        isRequired?: boolean;
        isInherited?: boolean;
        isEncrypted?: boolean;
        defaultValue?: unknown;
        valueTransforms?: AXPValueTransformerFunctions;
        validationRules?: AXPValidationRules;
    }): this;
    endSection(): AXPSettingDefinitionGroupBuilder;
}

interface AXPSettingDefinitionProvider {
    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
}
declare const AXP_SETTING_DEFINITION_PROVIDER: InjectionToken<AXPSettingDefinitionProvider[]>;
declare class AXPSettingDefinitionProviderService {
    private providers;
    private cache;
    private load;
    reload(): Promise<void>;
    getListAsync(scope: AXPPlatformScopeKey): Promise<AXPSettingDefinitionGroup[]>;
    getList(scope: AXPPlatformScopeKey): AXPSettingDefinitionGroup[];
    defaultValues(): Promise<Record<string, unknown>>;
    findGroup(scope: AXPPlatformScopeKey, groupName: string): AXPGroupSearchResult;
    private searchRecursive;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefinitionProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingDefinitionProviderService>;
}
declare const AXP_SETTING_DEFAULT_VALUES_PROVIDERS: InjectionToken<AXPSettingDefaultValuesProvider[]>;
declare class AXPSettingDefaultValuesAggregatorService {
    private readonly definitionService;
    private readonly providers;
    getDefaults(): Promise<Record<string, unknown>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefaultValuesAggregatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingDefaultValuesAggregatorService>;
}

declare const AXP_SETTING_VALUE_PROVIDER: InjectionToken<AXPSettingValueProvider[]>;

interface AXPSettingsServiceInterface {
    load(): Promise<AXPSettingValue[]>;
    get<T = any>(key: string): Promise<T>;
    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
    scope(scope: AXPPlatformScope): ScopedSettingService;
}
declare class AXPSettingsService implements AXPSettingsServiceInterface {
    private readonly providers;
    private readonly injector;
    private readonly eventService;
    private readonly sessionService;
    private readonly scopedSettingsCache;
    readonly onChanged: Subject<AXPSettingChangedEvent>;
    readonly onLoaded: Subject<void>;
    constructor();
    reload(): Promise<void>;
    load(): Promise<AXPSettingValue[]>;
    get<T = any>(key: string): Promise<T>;
    defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
    scope(scope: AXPPlatformScope): ScopedSettingService;
    invokeChangeEvent(event: AXPSettingChangedEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsService>;
}
declare class ScopedSettingService {
    private parent;
    private provider;
    private scopeCache;
    constructor(parent: AXPSettingsService, provider: AXPSettingValueProvider, scopeCache: Map<string, any>);
    get<T = any>(key: string): Promise<T>;
    all(): Promise<any>;
    defaultValues(): Promise<Record<string, unknown>>;
    set<T = any>(key: string, value: T): Promise<void>;
    set<T = any>(values: Record<string, T>): Promise<void>;
    update<T = any>(key: string, updateFn: (currentValue: T) => T): Promise<void>;
}

/**
 * Regional settings keys for date, time, and locale formatting.
 * These keys are used by platform widgets and components to access regional settings.
 * The actual setting definitions and providers are implemented in the locale-management module.
 */
declare enum AXPRegionalSetting {
    LocaleProfile = "LocaleManagement:Setting:Regional.LocaleProfile",
    TimeZone = "LocaleManagement:Setting:Regional.TimeZone",
    Language = "LocaleManagement:Setting:Regional.Language",
    Country = "LocaleManagement:Setting:Regional.Country",
    Calendar = "LocaleManagement:Setting:Regional.Calendar",
    FirstDayOfWeek = "LocaleManagement:Setting:Regional.FirstDayOfWeek",
    WeekendDays = "LocaleManagement:Setting:Regional.WeekendDays",
    ShortDate = "LocaleManagement:Setting:Regional.ShortDate",
    MediumDate = "LocaleManagement:Setting:Regional.MediumDate",
    LongDate = "LocaleManagement:Setting:Regional.LongDate",
    ShortTime = "LocaleManagement:Setting:Regional.ShortTime",
    MediumTime = "LocaleManagement:Setting:Regional.MediumTime",
    LongTime = "LocaleManagement:Setting:Regional.LongTime",
    MeasurementUnits = "LocaleManagement:Setting:Regional.MeasurementUnits",
    TemperatureUnits = "LocaleManagement:Setting:Regional.TemperatureUnits",
    DistanceUnits = "LocaleManagement:Setting:Regional.DistanceUnits",
    WeightUnits = "LocaleManagement:Setting:Regional.WeightUnits",
    VolumeUnits = "LocaleManagement:Setting:Regional.VolumeUnits",
    SpeedUnits = "LocaleManagement:Setting:Regional.SpeedUnits",
    AreaUnits = "LocaleManagement:Setting:Regional.AreaUnits"
}

/**
 * Status Definition Types
 * Defines the structure for status definitions and their transitions
 */
/**
 * Status definition with metadata
 */
interface AXPStatusDefinition {
    /**
     * Unique identifier for the status
     */
    name: string;
    /**
     * Display title for the status
     */
    title: string;
    /**
     * Color code or semantic color name for the status
     */
    color: string;
    /**
     * Optional icon class (e.g., 'fa-light fa-check')
     */
    icon?: string;
    /**
     * Optional description
     */
    description?: string;
    /**
     * Optional order for sorting
     */
    order?: number;
    /**
     * Whether this is a final status (end state)
     */
    isFinal?: boolean;
    /**
     * Whether this is an initial status (starting state)
     */
    isInitial?: boolean;
    /**
     * Whether list views should be automatically generated for this status
     */
    generateView?: boolean;
}
/**
 * Status transition definition
 */
interface AXPStatusTransition {
    /**
     * Source status name
     */
    from: string;
    /**
     * Target status name
     */
    to: string;
    /**
     * Optional condition expression to evaluate before allowing transition
     * Uses expression evaluator syntax (e.g., "{{user.isAdmin}}", "{{item.priority > 5}}")
     */
    condition?: string;
    /**
     * Optional display title for the transition
     */
    title?: string;
    /**
     * Optional description
     */
    description?: string;
    /**
     * Optional command descriptor to execute for this transition
     * If not provided, defaults to Entity:UpdateStatus with entity, id, and status
     */
    command?: {
        name: string;
        options?: Record<string, unknown>;
    };
    /**
     * Whether this transition is automatic (no user action required)
     */
    isAutomatic?: boolean;
    /**
     * Whether this transition requires approval
     */
    requiresApproval?: boolean;
}
/**
 * Abstract class for status providers
 * Similar to AXPTaskBadgeProvider pattern
 */
declare abstract class AXPStatusProvider {
    /**
     * Unique key for the status (e.g., 'task-management.status')
     */
    abstract readonly key: string;
    /**
     * List of available status definitions
     */
    abstract readonly statuses: AXPStatusDefinition[];
    /**
     * List of allowed transitions between statuses
     */
    abstract readonly transitions: AXPStatusTransition[];
    /**
     * Optional default status name
     */
    abstract readonly defaultStatus?: string;
}

/**
 * Injection token for status providers
 * Use with multi: true to register multiple providers
 */
declare const AXP_STATUS_PROVIDERS: InjectionToken<AXPStatusProvider[]>;
/**
 * Service for managing status definitions from multiple providers
 * Similar to AXPTaskBadgeService pattern - no cache, direct access
 *
 * @example
 * ```typescript
 * // In a module providers array:
 * {
 *   provide: AXP_STATUS_PROVIDERS,
 *   useClass: TaskStatusProvider,
 *   multi: true,
 * }
 *
 * // Example provider implementation:
 * export class TaskStatusProvider extends AXPStatusProvider {
 *   readonly key = 'task-management.status';
 *   readonly statuses = [
 *     { name: 'todo', title: 'To Do', color: '#6b7280', icon: 'fa-light fa-circle', isInitial: true },
 *     { name: 'in-progress', title: 'In Progress', color: '#3b82f6', icon: 'fa-light fa-play' },
 *     { name: 'done', title: 'Done', color: '#10b981', icon: 'fa-light fa-check-circle', isFinal: true },
 *   ];
 *   readonly transitions = [
 *     { from: 'todo', to: 'in-progress', title: 'Start', condition: '{{user.canEdit}}' },
 *     { from: 'in-progress', to: 'done', title: 'Complete' },
 *   ];
 *   readonly defaultStatus = 'todo';
 * }
 *
 * // Later, get the status:
 * const status = await statusService.getStatus('task-management.status');
 * if (status) {
 *   console.log('Statuses:', status.statuses);
 *   console.log('Transitions:', status.transitions);
 * }
 * ```
 */
declare class AXPStatusDefinitionProviderService {
    private providers;
    private commandService;
    private statusMap;
    private initializationPromise;
    private isInitialized;
    /**
     * Initialize providers (resolve promises if needed)
     * Called lazily on first access
     */
    private initialize;
    private _doInitialize;
    /**
     * Get a status provider by key
     * Ensures initialization is complete before accessing the status map.
     *
     * @param key - Status key (e.g., 'task-management.status')
     * @returns Promise that resolves to status provider with all statuses and transitions, or undefined if not found
     *
     * @example
     * ```typescript
     * const status = await statusService.getStatus('task-management.status');
     * if (status) {
     *   console.log('Statuses:', status.statuses);
     *   console.log('Transitions:', status.transitions);
     * }
     * ```
     */
    getStatus(key: string): Promise<AXPStatusProvider | undefined>;
    /**
     * Execute a status transition workflow action
     * Uses transition.command if provided, otherwise defaults to Entity:UpdateStatus
     * Validates the transition is allowed before executing
     *
     * @param definitionKey - Status definition key
     * @param transition - The transition to execute
     * @param context - Context data for the command (must include entity name and id/ids)
     * @returns Promise that resolves when the command execution completes
     *
     * @example
     * ```typescript
     * await statusService.executeTransition(
     *   'task-management.status',
     *   { from: 'todo', to: 'in-progress' },
     *   { entity: 'TaskManagement.Task', id: '123', ...entityData }
     * );
     * ```
     */
    executeTransition(definitionKey: string, transition: AXPStatusTransition, context: Record<string, any>): Promise<void>;
    /**
     * Validate if a transition is allowed
     * Checks if the transition exists in the provider's transitions list
     */
    private isValidTransition;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPStatusDefinitionProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPStatusDefinitionProviderService>;
}

/**
 * Standard system status types
 * These are the predefined status values used across the platform
 */
declare enum AXPSystemStatusType {
    Todo = "todo",
    InProgress = "in-progress",
    InReview = "in-review",
    Open = "open",
    Closed = "closed",
    Blocked = "blocked",
    Done = "done",
    Cancelled = "cancelled",
    Draft = "draft",
    PendingReview = "pending-review",
    Approved = "approved",
    Published = "published",
    Archived = "archived",
    Rejected = "rejected",
    Active = "active",
    Inactive = "inactive",
    Pending = "pending",
    Completed = "completed",
    Suspended = "suspended",
    Failed = "failed",
    Review = "review",
    Expired = "expired"
}
/**
 * Standard system status definitions
 * Provides consistent status definitions across the platform
 * Uses AXPStatusDefinition interface from status-definition.types.ts
 */
declare const AXPSystemStatuses: Readonly<{
    readonly Open: {
        readonly name: AXPSystemStatusType.Open;
        readonly title: string;
        readonly icon: "fa-light fa-circle";
        readonly color: "secondary";
        readonly description: string;
        readonly order: 1;
        readonly isInitial: true;
        readonly isFinal: false;
    };
    readonly Closed: {
        readonly name: AXPSystemStatusType.Closed;
        readonly title: string;
        readonly icon: "fa-light fa-circle";
        readonly color: "danger";
        readonly description: string;
        readonly order: 2;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Todo: {
        readonly name: AXPSystemStatusType.Todo;
        readonly title: string;
        readonly icon: "fa-light fa-circle";
        readonly color: "secondary";
        readonly description: string;
        readonly order: 1;
        readonly isInitial: true;
        readonly isFinal: false;
    };
    readonly InProgress: {
        readonly name: AXPSystemStatusType.InProgress;
        readonly title: string;
        readonly icon: "fa-light fa-play";
        readonly color: "info";
        readonly description: string;
        readonly order: 2;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly InReview: {
        readonly name: AXPSystemStatusType.InReview;
        readonly title: string;
        readonly icon: "fa-light fa-eye";
        readonly color: "info";
        readonly description: string;
        readonly order: 3;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Blocked: {
        readonly name: AXPSystemStatusType.Blocked;
        readonly title: string;
        readonly icon: "fa-light fa-ban";
        readonly color: "danger";
        readonly description: string;
        readonly order: 4;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Done: {
        readonly name: AXPSystemStatusType.Done;
        readonly title: string;
        readonly icon: "fa-light fa-check-circle";
        readonly color: "success";
        readonly description: string;
        readonly order: 5;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Cancelled: {
        readonly name: AXPSystemStatusType.Cancelled;
        readonly title: string;
        readonly icon: "fa-light fa-times-circle";
        readonly color: "neutral";
        readonly description: string;
        readonly order: 6;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Draft: {
        readonly name: AXPSystemStatusType.Draft;
        readonly title: string;
        readonly icon: "fa-light fa-file-pen";
        readonly color: "neutral";
        readonly description: string;
        readonly order: 1;
        readonly isInitial: true;
        readonly isFinal: false;
    };
    readonly PendingReview: {
        readonly name: AXPSystemStatusType.PendingReview;
        readonly title: string;
        readonly icon: "fa-light fa-clock";
        readonly color: "warning";
        readonly description: string;
        readonly order: 2;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Approved: {
        readonly name: AXPSystemStatusType.Approved;
        readonly title: string;
        readonly icon: "fa-light fa-check-circle";
        readonly color: "success";
        readonly description: string;
        readonly order: 3;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Published: {
        readonly name: AXPSystemStatusType.Published;
        readonly title: string;
        readonly icon: "fa-light fa-globe";
        readonly color: "primary";
        readonly description: string;
        readonly order: 4;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Archived: {
        readonly name: AXPSystemStatusType.Archived;
        readonly title: string;
        readonly icon: "fa-light fa-archive";
        readonly color: "danger";
        readonly description: string;
        readonly order: 5;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Rejected: {
        readonly name: AXPSystemStatusType.Rejected;
        readonly title: string;
        readonly icon: "fa-light fa-times-circle";
        readonly color: "danger";
        readonly description: string;
        readonly order: 6;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Active: {
        readonly name: AXPSystemStatusType.Active;
        readonly title: string;
        readonly icon: "fa-light fa-check-circle";
        readonly color: "success";
        readonly description: string;
        readonly order: 1;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Inactive: {
        readonly name: AXPSystemStatusType.Inactive;
        readonly title: string;
        readonly icon: "fa-light fa-circle";
        readonly color: "secondary";
        readonly description: string;
        readonly order: 2;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Pending: {
        readonly name: AXPSystemStatusType.Pending;
        readonly title: string;
        readonly icon: "fa-light fa-clock";
        readonly color: "warning";
        readonly description: string;
        readonly order: 1;
        readonly isInitial: true;
        readonly isFinal: false;
    };
    readonly Completed: {
        readonly name: AXPSystemStatusType.Completed;
        readonly title: string;
        readonly icon: "fa-light fa-check-circle";
        readonly color: "success";
        readonly description: string;
        readonly order: 10;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Suspended: {
        readonly name: AXPSystemStatusType.Suspended;
        readonly title: string;
        readonly icon: "fa-light fa-pause-circle";
        readonly color: "neutral";
        readonly description: string;
        readonly order: 5;
        readonly isInitial: false;
        readonly isFinal: false;
    };
    readonly Failed: {
        readonly name: AXPSystemStatusType.Failed;
        readonly title: string;
        readonly icon: "fa-light fa-xmark-circle";
        readonly color: "danger";
        readonly description: string;
        readonly order: 10;
        readonly isInitial: false;
        readonly isFinal: true;
    };
    readonly Review: {
        readonly name: AXPSystemStatusType.Review;
        readonly title: string;
        readonly icon: "fa-light fa-eye";
        readonly color: "info";
        readonly description: string;
        readonly order: 3;
    };
    readonly Expired: {
        readonly name: AXPSystemStatusType.Expired;
        readonly title: string;
        readonly icon: "fa-light fa-clock";
        readonly color: "danger";
        readonly description: string;
        readonly order: 10;
        readonly isInitial: false;
        readonly isFinal: true;
    };
}>;
/**
 * Get system status definition by type
 * @param type - Status type
 * @returns System status definition or undefined
 */
declare function getSystemStatus(type: AXPSystemStatusType): AXPStatusDefinition;
/**
 * Resolves the visual appearance (color and icon) for status
 * using the system statuses from the core module.
 * @param statusType - Status type string
 * @returns Color and icon for the status
 */
declare function resolveStatusLook(statusType: string): {
    color: AXStyleColorType;
    icon: string;
};
/**
 * Resolves the complete status information (title, description, icon, color) for a status
 * using the system statuses from the core module.
 * @param statusType - Status type string
 * @returns Complete status information as AXPStatusDefinition
 */
declare function getStatusInfo(statusType: string): AXPStatusDefinition;
/**
 * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
 * @param statusType - Status type
 * @param overrides - Optional overrides for the status definition
 * @returns AXPStatusDefinition
 */
declare function systemStatusToDefinition(statusType: AXPSystemStatusType, overrides?: Partial<AXPStatusDefinition>): AXPStatusDefinition;

interface AXPTokenDefinition {
    name: string;
    execute: () => Promise<any> | any;
}

type AXPTokenDefinitionProviderToken = AXPTokenDefinitionProvider | Promise<AXPTokenDefinitionProvider>;
declare const AXP_TOKEN_DEFINITION_PROVIDER: InjectionToken<AXPTokenDefinitionProviderToken[]>;
interface AXPTokenDefinitionProvider<T = any> {
    name: string;
    title: string;
    description?: string;
    execute(): Promise<T> | T;
}

declare class AXPTokenDefinitionService {
    private readonly definitionProviders;
    /** Cache for definitions by name. */
    private definitionsByName;
    /**
     * Returns a token definition by its name.
     * First checks the cache, then queries all providers if not found.
     * @param name The token name.
     * @returns The token definition if found, undefined otherwise.
     */
    getDefinition(name: string): Promise<AXPTokenDefinition | undefined>;
    /**
     * Gets the resolved value of a token by its name.
     * @param name The token name.
     * @returns The resolved token value, or undefined if the token is not found.
     */
    getValue(name: string): Promise<any>;
    /** Clears the definitions by name cache. */
    clearDefinitionsCache(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTokenDefinitionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTokenDefinitionService>;
}

declare class AXPTokenEvaluatorScopeProvider implements AXPExpressionEvaluatorScopeProvider {
    protected tokenService: AXPTokenDefinitionService;
    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
}

declare class AXPClipBoardService {
    private toast;
    copy(title: string, value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPClipBoardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPClipBoardService>;
}

/**
 * Service for debugging user access information.
 * Displays loaded modules, features, and permissions for the current user.
 */
declare class AXPDebugService {
    private readonly sessionService;
    private readonly manifestRegistry;
    /**
     * Display all loaded modules, features, and permissions for the current user.
     */
    displayUserAccessInfo(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDebugService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDebugService>;
}

declare class AXPExportService {
    popupService: AXPopupService;
    generateBlobFromElement(element: HTMLElement, blobOptions?: AXPDomToImageOptions): Promise<Blob>;
    download(blob: Blob, filename: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPExportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPExportService>;
}
interface AXPDomToImageOptions {
    popup?: true;
    filter?: (node: Node) => boolean;
    bgcolor?: string;
    width?: number;
    height?: number;
    style?: {};
    quality?: number;
    imagePlaceholder?: string;
    cacheBust?: boolean;
    scale?: number;
}

declare function AXPCleanNestedFilters(filters: AXDataSourceFilterOption[]): AXDataSourceFilterOption[];

interface AXPLocaleProfile extends AXLocaleProfile {
    code: string;
    title: string;
    nativeTitle: string;
}
interface AXPLanguage {
    code: string;
    title: string;
}
interface AXPGeoLocation {
    id: string;
    code: string;
    title: string;
    timezone?: string;
}
interface AXPTimeZone {
    code: string;
    title: string;
    offset: number;
    iana: string;
    abbr: string;
}
interface AXPCurrency {
    code: string;
    title: string;
    symbol: string;
    format: string;
}

interface AXPVersionStream {
    id: string;
    entityType: string;
    entityId: string;
    createdAt: string;
}
declare enum AXVChangeType {
    Create = "Create",
    Update = "Update",
    Delete = "Delete"
}
type CanonicalChangeOp = 'add' | 'remove' | 'replace' | 'rename' | 'metadata';
interface CanonicalChange {
    path: string;
    op: CanonicalChangeOp;
    oldValue?: unknown;
    newValue?: unknown;
    meta?: Record<string, unknown>;
}
interface AXPVersionEntry {
    id: string;
    streamId: string;
    versionNumber: number;
    changeType: AXVChangeType;
    changedBy: string;
    changedAt: string;
    snapshotJson: unknown;
    patchFromPrevJson: CanonicalChange[];
    summary?: string;
    metadataJson?: unknown;
}
interface AXPVersionChange {
    id?: number;
    versionEntryId: string;
    path: string;
    op: CanonicalChangeOp;
    oldValue?: unknown;
    newValue?: unknown;
}
interface VersionedFileInfo {
    id: string;
    name: string;
    size: number;
    mime: string;
    hash: string;
    url?: string;
    thumbUrl?: string;
}
declare abstract class AXPVersioningService {
    abstract getStreamIdIfExists(entityType: string, entityId: string): Promise<string | null>;
    abstract listEntries(streamId: string, options?: {
        limit?: number;
        offset?: number;
    }): Promise<AXPVersionEntry[]>;
    abstract getUiFriendlyDiff(streamId: string, v1: number, v2: number): Promise<Array<{
        badge: string;
        path: string;
        summary: string;
        oldValue?: unknown;
        newValue?: unknown;
    }>>;
}

declare const AXPRedirectEvent: {
    (payload: {
        url: string;
    }): {
        type: string;
        payload: {
            url: string;
        };
    };
    type: string;
};
declare const AXPRefreshEvent: {
    (payload: {
        entity: string;
        meta?: any;
    }): {
        type: string;
        payload: {
            entity: string;
            meta?: any;
        };
    };
    type: string;
};
declare const AXPReloadEvent: {
    (payload: {
        entity: string;
        meta?: any;
    }): {
        type: string;
        payload: {
            entity: string;
            meta?: any;
        };
    };
    type: string;
};
declare class AXPWorkflowNavigateAction extends AXPWorkflowAction {
    private router;
    execute(context: AXPWorkflowContext): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowNavigateAction, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowNavigateAction>;
}
declare class AXPDialogConfirmAction extends AXPWorkflowAction {
    private dialogService;
    private translationService;
    title: string;
    message: string;
    type: AXStyleColorType;
    defaultAction: string;
    execute(context: AXPWorkflowContext): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDialogConfirmAction, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDialogConfirmAction>;
}
declare class AXPToastAction extends AXPWorkflowAction {
    private toastService;
    private translationService;
    private settingsService;
    color: AXStyleColorType;
    title: string;
    content: string;
    execute(context: AXPWorkflowContext): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPToastAction, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPToastAction>;
}
declare class AXPReloadAction extends AXPWorkflowAction {
    execute(context: AXPWorkflowContext): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPReloadAction, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPReloadAction>;
}

declare class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
    private router;
    execute(context: AXPWorkflowContext): Promise<void>;
    /**
     * Parses query parameters from a query string into an object.
     */
    private parseQueryParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowRouterNavigateAction, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowRouterNavigateAction>;
}
declare const AXPNavigateWorkflow: AXPWorkflow;

declare class AXMWorkflowErrorHandler implements AXPErrorHandler {
    private dialog;
    handleError(error: any, next: (error: any) => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMWorkflowErrorHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMWorkflowErrorHandler>;
}

export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalSetting, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPStickyDirective, AXPSystemStatusType, AXPSystemStatuses, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TOKEN_DEFINITION_PROVIDER, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, configPlatform, createAllQueryView, createMenuContext, createMenuMiddleware, createQueryView, getEntityInfo, getStatusInfo, getSystemStatus, provideDynamicHomePage, provideMenuMiddleware, resolveStatusLook, systemStatusToDefinition };
export type { AXCFileUploaderAction, AXCFileUploaderActionsPayload, AXCFileUploaderCapabilities, AXEntityPropertyWidget, AXPAggregate, AXPAppVersion, AXPAppVersionProvider, AXPApplication, AXPCategoryEntity, AXPCommandActionCallback, AXPCommandActionDisplay, AXPCommandActionLook, AXPCommandActionPriority, AXPCommandActionType, AXPCommonModuleConfigs, AXPCurrency, AXPDomToImageOptions, AXPEntity, AXPEntityAction, AXPEntityCommand, AXPEntityDetailListView, AXPEntityMasterCreateLayoutView, AXPEntityMasterLayoutView, AXPEntityMasterListView, AXPEntityMasterSingleLayoutView, AXPEntityMasterUpdateLayoutView, AXPEntityProperty, AXPEntityPropertyCreateView, AXPEntityPropertyGroup, AXPEntityPropertyLayoutConfig, AXPEntityPropertyUpdateView, AXPEntityPropertyView, AXPEntityQuery, AXPEntitySectionView, AXPEntityTableColumn, AXPEntityVersionHistory, AXPErrorHandler, AXPFileActionProvider, AXPFileActionProviderToken, AXPFileExtension, AXPFileManyStorageInfo, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFileType, AXPFileTypeInfoProvider, AXPFilterOperator, AXPGeoLocation, AXPGroupSearchResult, AXPHomePageDefinition, AXPLanguage, AXPLocaleProfile, AXPLockGetInfoRequest, AXPLockInfo, AXPLockRequest, AXPLockType, AXPMenuFinderResult, AXPMenuInsertion, AXPMenuItem, AXPMenuItemCommand, AXPMenuItemFinder, AXPMenuItemWithParent, AXPMenuMiddleware, AXPMenuMiddlewareContext, AXPMenuMiddlewareProvider, AXPMenuProvider, AXPMenuProviderContext, AXPMenuType, AXPModule, AXPPlatformConfigs, AXPQueryFilter, AXPQuerySort, AXPQueryView, AXPRelatedEntity, AXPRelationship, AXPRootConfigs, AXPSearchAction, AXPSearchDefinition, AXPSearchDefinitionDisplayFormat, AXPSearchDefinitionProvider, AXPSearchDisplayGroupResult, AXPSearchDisplayResult, AXPSearchDisplayResultForSave, AXPSearchParentResult, AXPSearchProvider, AXPSearchResult, AXPSettingChangedEvent, AXPSettingDefaultValuesProvider, AXPSettingDefinition, AXPSettingDefinitionGroup, AXPSettingDefinitionProvider, AXPSettingDefinitionSection, AXPSettingValue, AXPSettingValueProvider, AXPSettingsServiceInterface, AXPStatusDefinition, AXPStatusTransition, AXPTimeZone, AXPTokenDefinition, AXPTokenDefinitionProvider, AXPTokenDefinitionProviderToken, AXPUnLockRequest, AXPVersionChange, AXPVersionEntry, AXPVersionStream, CanonicalChange, CanonicalChangeOp, VersionedFileInfo };
