import * as _angular_core from '@angular/core';
import { Signal, InjectionToken, InputSignal, TemplateRef, ElementRef, OnDestroy, OnInit, Type, ViewContainerRef, ModuleWithProviders, QueryList, OnChanges, EventEmitter, WritableSignal } from '@angular/core';
import * as _acorex_platform_core from '@acorex/platform/core';
import { AXPActivityLog, AXPSystemActionType, AXPCategoryEntity, AXPColumnQuery, AXPContextData, AXPOptionsData, AXPFilterDefinition, AXPFilterQuery, AXPSortDefinition, AXPSortQuery, AXPMetaData, AXPViewQuery } from '@acorex/platform/core';
import { AXPMenuItem } from '@acorex/platform/common';
import { AXValueChangedEvent, AXClickEvent, AXDataSource, AXDataSourceFilterOption, AXHtmlEvent, AXEvent } from '@acorex/cdk/common';
import { AXTreeViewLegacyComponent, AXTreeItemClickBaseEventLegacy } from '@acorex/components/tree-view-legacy';
import { AXTranslationService } from '@acorex/core/translation';
import { AXPopoverComponent } from '@acorex/components/popover';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { AXPWidgetNode, AXPWidgetRendererDirective, AXPWidgetCoreContextChangeEvent, AXPWidgetProperty, AXPWidgetConfig } from '@acorex/platform/layout/widget-core';
import * as _ngrx_signals from '@ngrx/signals';
import { AXDataTableComponent, AXDataTableRowDbClick, AXDataTableRowClick } from '@acorex/components/data-table';
import { AXBasePageComponent } from '@acorex/components/page';
import { AXDropListDroppedEvent } from '@acorex/cdk/drag-drop';
import { AXTagBoxComponent } from '@acorex/components/tag-box';
import { AXCalendarService } from '@acorex/core/date-time';
import { AXTabStripChangedEvent, AXTabsComponent } from '@acorex/components/tabs';
import { AXFormComponent } from '@acorex/components/form';
import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
import { Observable } from 'rxjs';

declare class AXPActivityLogComponent {
    private readonly translateService;
    private readonly workflowService;
    /**
     * Array of activity logs to display
     */
    activities: _angular_core.InputSignal<AXPActivityLog[]>;
    /**
     * Whether the component is in loading state
     */
    loading: _angular_core.InputSignal<boolean>;
    protected readonly i18nScope = "activity-log";
    protected readonly Object: ObjectConstructor;
    /**
     * Set of expanded activity IDs
     */
    private expandedItems;
    /**
     * Flag to track if component has been initialized
     */
    private isInitialized;
    /**
     * Set of items that have been manually toggled (for animation control)
     */
    private manuallyToggledItems;
    constructor();
    /**
     * Gets the appropriate CSS class for the change type
     */
    protected getChangeClasses(changeType: AXPSystemActionType): {
        surface: string;
        text: string;
        icon: string;
    };
    /**
 * Checks if an activity item is expanded
 */
    protected isExpanded(activityId: string): boolean;
    /**
 * Toggles the expanded state of an activity item
 */
    protected toggleExpanded(activityId: string): void;
    /**
     * Checks if an item should have expand/collapse animation
     */
    protected shouldAnimate(activityId: string): boolean;
    /**
     * Checks if an activity has expandable content (changes)
     */
    protected hasExpandableContent(activity: AXPActivityLog): boolean;
    /**
     * Handles the compare action for an activity
     */
    protected handleCompare(activity: AXPActivityLog, event: Event): Promise<void>;
    /**
     * Checks if an activity can be compared (has a previous version)
     */
    protected canCompare(activity: AXPActivityLog): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPActivityLogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPActivityLogComponent, "axp-activity-log", never, { "activities": { "alias": "activities"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AXPTaskBadgeService {
    private badgeMap;
    private providers;
    private computedCache;
    constructor();
    getCount(key: string): Signal<number>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBadgeService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTaskBadgeService>;
}

declare const AXP_TASK_BADGE_PROVIDERS: InjectionToken<AXPTaskBadgeProvider[]>;
declare abstract class AXPTaskBadgeProvider {
    abstract key: string;
    abstract count: Signal<number>;
}

declare class AXPTaskBadgeDirective {
    #private;
    private badgeService;
    private host;
    private hostElement;
    badgeKey: InputSignal<string | undefined>;
    count: InputSignal<number>;
    private readonly displayCount;
    private setValueOfInputSignal;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBadgeDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPTaskBadgeDirective, "[axp-task-badge]", never, { "badgeKey": { "alias": "badgeKey"; "required": false; "isSignal": true; }; "count": { "alias": "axp-task-badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AXPMenuBadgeHelper {
    private static cache;
    static getTotalCount(item: AXPMenuItem, badgeService: AXPTaskBadgeService): Signal<number>;
}

declare class AXPThemeLayoutPagePrimaryActionsComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutPagePrimaryActionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutPagePrimaryActionsComponent, "axp-layout-actions-primary", never, {}, {}, never, ["ax-button,ax-dropdown-button"], true, never>;
}
declare class AXPThemeLayoutPageSecondaryActionsComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutPageSecondaryActionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutPageSecondaryActionsComponent, "axp-layout-actions-secondary", never, {}, {}, never, ["ax-button-item,ax-divider,ng-container"], true, never>;
}
declare class AXPThemeLayoutActionsComponent {
    readonly primaryTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    private readonly primaryContent;
    hasPrimary: _angular_core.Signal<boolean>;
    readonly secondaryTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    private readonly secondaryContent;
    hasSecondary: _angular_core.Signal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutActionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutActionsComponent, "axp-layout-actions", never, {}, {}, ["primaryContent", "secondaryContent"], ["axp-layout-actions-primary", "axp-layout-actions-secondary", "*"], true, never>;
}

declare class AXPThemeLayoutBlockComponent {
    protected readonly elementRef: ElementRef<any>;
    readonly hostElement: any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutBlockComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutBlockComponent, "    axp-page-content,     axp-page-footer-container,    axp-page-footer,    axp-page-header,    axp-page-header-container,    axp-page-toolbar,    axp-layout-content,     axp-layout-page-content,     axp-layout-sections,    axp-layout-body,    axp-layout-page-body,    axp-layout-prefix,    axp-layout-suffix,    axp-layout-title-bar,    axp-layout-title,     axp-layout-title-actions,     axp-layout-nav-button,     axp-layout-description,     axp-layout-breadcrumbs,    axp-layout-list-action,    ", never, {}, {}, never, ["*"], true, never>;
}

declare class AXPThemeLayoutFooterComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutFooterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutFooterComponent, "axp-layout-footer, axp-layout-page-footer", never, {}, {}, never, ["axp-layout-prefix", "*", "axp-layout-suffix"], true, never>;
}

declare class AXPThemeLayoutPageHeaderComponent {
    readonly title: _angular_core.Signal<TemplateRef<any> | undefined>;
    readonly description: _angular_core.Signal<TemplateRef<any> | undefined>;
    readonly actions: _angular_core.Signal<TemplateRef<any> | undefined>;
    readonly navbar: _angular_core.Signal<TemplateRef<any> | undefined>;
    readonly breadcrumbs: _angular_core.Signal<TemplateRef<any> | undefined>;
    readonly navButton: _angular_core.Signal<TemplateRef<any> | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutPageHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutPageHeaderComponent, "axp-layout-page-header", never, {}, {}, never, ["axp-layout-breadcrumbs", "axp-layout-toolbar", "axp-layout-actions", "axp-layout-description", "axp-layout-title", "axp-layout-nav-button"], true, never>;
}
declare class AXPThemeLayoutHeaderComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutHeaderComponent, "axp-layout-header", never, {}, {}, never, ["axp-layout-prefix", "*", "axp-layout-suffix"], true, never>;
}

declare class AXPThemeLayoutListComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutListComponent, "axp-layout-list", never, {}, {}, never, ["axp-layout-list-item,axp-layout-list-group,ng-container"], true, never>;
}
declare class AXPThemeLayoutListItemsGroupComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutListItemsGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutListItemsGroupComponent, "axp-layout-list-group", never, {}, {}, never, ["axp-layout-list-item, axp-layout-title, axp-layout-header ,ng-container"], true, never>;
}
declare class AXPThemeLayoutListItemComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutListItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutListItemComponent, "axp-layout-list-item", never, {}, {}, never, ["axp-layout-content,axp-layout-prefix,axp-layout-suffix,ng-container"], true, never>;
}

declare class AXPThemeLayoutSectionComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutSectionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutSectionComponent, "axp-layout-section", never, {}, {}, never, ["axp-layout-header", "axp-layout-content"], true, never>;
}

declare class AXPThemeLayoutStartSideComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutStartSideComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutStartSideComponent, "axp-layout-page-start-side, axp-layout-start-side", never, {}, {}, never, ["axp-layout-header", "axp-layout-content", "axp-layout-footer", "*"], true, never>;
}
declare class AXPThemeLayoutEndSideComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutEndSideComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutEndSideComponent, "axp-layout-page-end-side, axp-layout-end-side", never, {}, {}, never, ["axp-layout-header", "axp-layout-content", "axp-layout-footer"], true, never>;
}

declare class AXPThemeLayoutToolbarComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutToolbarComponent, "axp-layout-toolbar", never, {}, {}, never, ["axp-layout-prefix", "axp-layout-suffix", "*"], true, never>;
}

declare class AXPThemeLayoutContainerComponent {
    protected readonly elementRef: ElementRef<HTMLDivElement>;
    readonly hostElement: HTMLDivElement;
    private _isEmptySignal;
    readonly isEmpty: Signal<boolean>;
    private mutationObserver?;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutContainerComponent, "axp-layout-container", never, {}, {}, never, ["*"], true, never>;
}

interface AXPCategoryTreeNode extends AXPCategoryEntity {
    children?: AXPCategoryTreeNode[];
    expand?: boolean;
    hasChild?: boolean;
    [key: string]: any;
}
interface AXPCategoryTreeConfig {
    textField?: string;
    valueField?: string;
    expandedField?: string;
    showCheckbox?: boolean;
    searchable?: boolean;
    searchPlaceholder?: string;
    emptyStateTitle?: string;
    emptyStateDescription?: string;
    emptyStateIcon?: string;
}
interface AXPCategoryTreeEvents {
    onNodeClick?: (node: AXPCategoryEntity) => void;
    onNodeSelect?: (node: AXPCategoryEntity) => void;
    onNodeCreate?: (parentNode?: AXPCategoryEntity) => void;
    onNodeUpdate?: (node: AXPCategoryEntity) => void;
    onNodeDelete?: (node: AXPCategoryEntity) => void;
    onSearchChange?: (searchValue: string) => void;
    onCollapseChange?: (node: AXPCategoryEntity) => void;
}
interface AXPCategoryTreeActions {
    canCreate?: boolean;
    canUpdate?: boolean;
    canDelete?: boolean;
    canCreateChild?: boolean;
    createLabel?: string;
    updateLabel?: string;
    deleteLabel?: string;
    createChildLabel?: string;
}
interface AXPCategoryTreeDataSource {
    loadRootNodes: () => Promise<AXPCategoryEntity[]>;
    loadChildNodes?: (parentId: string) => Promise<AXPCategoryEntity[]>;
    searchNodes?: (searchValue: string) => Promise<AXPCategoryEntity[]>;
}

declare class AXPCategoryTreeComponent {
    protected readonly translationService: AXTranslationService;
    dataSource: _angular_core.InputSignal<AXPCategoryTreeDataSource>;
    config: _angular_core.InputSignal<AXPCategoryTreeConfig>;
    actions: _angular_core.InputSignal<AXPCategoryTreeActions>;
    events: _angular_core.InputSignal<AXPCategoryTreeEvents>;
    nodeClick: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
    nodeSelect: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
    nodeCreate: _angular_core.OutputEmitterRef<AXPCategoryEntity<string> | undefined>;
    nodeUpdate: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
    nodeDelete: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
    searchChange: _angular_core.OutputEmitterRef<string>;
    collapseChange: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
    tree: _angular_core.Signal<AXTreeViewLegacyComponent | undefined>;
    isLoading: _angular_core.WritableSignal<boolean>;
    searchValue: _angular_core.WritableSignal<string>;
    private loadingTimeoutId;
    private readonly LOADING_DELAY;
    protected treeItems: _angular_core.WritableSignal<AXPCategoryTreeNode[]>;
    protected emptyStateTitle: _angular_core.Signal<string>;
    protected emptyStateDescription: _angular_core.Signal<string>;
    ngOnInit(): Promise<void>;
    loadRootNodes(): Promise<void>;
    loadChildNodes(parentId: string): Promise<void>;
    searchNodes(searchValue: string): Promise<void>;
    handleNodeClick(event: AXTreeItemClickBaseEventLegacy): Promise<void>;
    handleCollapseChanged(event: AXTreeItemClickBaseEventLegacy): Promise<void>;
    handleSearchChange(event: AXValueChangedEvent): Promise<void>;
    handleCreateRootClick(event: AXClickEvent): Promise<void>;
    handleCreateChildClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
    handleUpdateNodeClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
    handleDeleteNodeClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
    private convertEntitiesToTreeNodes;
    private updateNodeChildren;
    refreshTree(parentId?: string): Promise<void>;
    /**
     * Set loading state with delay to avoid flickering for fast responses
     */
    private setLoadingWithDelay;
    /**
     * Clear loading state and cancel any pending timeout
     */
    private clearLoadingState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCategoryTreeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPCategoryTreeComponent, "axp-category-tree", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeSelect": "nodeSelect"; "nodeCreate": "nodeCreate"; "nodeUpdate": "nodeUpdate"; "nodeDelete": "nodeDelete"; "searchChange": "searchChange"; "collapseChange": "collapseChange"; }, never, never, true, never>;
}

/**
 * Color Palette Picker Component
 * Displays a grid of color swatches for selection
 */
declare class AXPColorPalettePickerComponent {
    /**
     * Array of color codes to display
     */
    colors: _angular_core.InputSignal<string[]>;
    /**
     * Currently selected color
     */
    selectedColor: _angular_core.InputSignal<string | null | undefined>;
    /**
     * Disable the entire palette
     */
    disabled: _angular_core.InputSignal<boolean>;
    /**
     * Make the palette readonly
     */
    readonly: _angular_core.InputSignal<boolean>;
    /**
     * Show empty/null option to clear selection
     */
    allowClear: _angular_core.InputSignal<boolean>;
    /**
     * Emits when a color is selected or cleared (null/undefined)
     */
    colorSelected: _angular_core.OutputEmitterRef<string | null | undefined>;
    /**
     * Handle color selection
     */
    protected handleColorSelect(color: string | null | undefined): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColorPalettePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPColorPalettePickerComponent, "axp-color-palette-picker", never, { "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "selectedColor": { "alias": "selectedColor"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "allowClear": { "alias": "allowClear"; "required": false; "isSignal": true; }; }, { "colorSelected": "colorSelected"; }, never, never, true, never>;
}

interface AXPColumnItemListItem {
    id: string;
    content: string;
}
declare class AXPColumnItemListComponent implements OnDestroy {
    items: _angular_core.InputSignal<AXPColumnItemListItem[]>;
    itemTemplate: _angular_core.InputSignal<TemplateRef<{
        $implicit: AXPColumnItemListItem;
    }> | null>;
    itemClick: _angular_core.OutputEmitterRef<AXPColumnItemListItem>;
    protected itemsContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
    protected moreButton: _angular_core.Signal<ElementRef<any> | undefined>;
    protected morePopover: _angular_core.Signal<AXPopoverComponent | undefined>;
    protected isMorePopoverOpen: _angular_core.WritableSignal<boolean>;
    protected hasOverflow: _angular_core.WritableSignal<boolean>;
    private resizeObserver?;
    constructor();
    ngOnDestroy(): void;
    protected showMoreItems(): void;
    protected onMorePopoverOpenChange(event: any): void;
    private openMorePopover;
    protected submitClick(event: AXPColumnItemListItem): void;
    private checkOverflow;
    private setupResizeObserver;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColumnItemListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPColumnItemListComponent, "axp-column-item-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
}

declare class AXPQueryColumnsComponent {
    columns: _angular_core.ModelSignal<AXPColumnQuery[]>;
    handleVisibilityChange(e: AXValueChangedEvent<boolean>, name: string): void;
    protected drop(event: CdkDragDrop<unknown[]>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryColumnsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryColumnsComponent, "axp-query-columns", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "columns": "columnsChange"; }, never, never, true, never>;
}

interface AXPCompareViewField {
    path: string;
    title: string;
    description?: string;
    widget: AXPWidgetNode;
}
interface AXPCompareViewObject {
    id: string;
    title: string;
    description?: string;
    context: AXPContextData;
}
interface AXPCompareViewInputs {
    fields: AXPCompareViewField[];
    objects: AXPCompareViewObject[];
}
type AXPCompareViewMode = 'compare' | 'changes';
declare class AXPCompareViewComponent implements OnInit, OnDestroy {
    inputs: _angular_core.InputSignal<AXPCompareViewInputs | undefined>;
    showOnlyChanges: _angular_core.WritableSignal<boolean>;
    mode: _angular_core.InputSignal<AXPCompareViewMode>;
    private removedObjects;
    protected isChangesMode: _angular_core.Signal<boolean>;
    /**
     * Filtered fields based on showOnlyChanges toggle
     */
    filteredFields: _angular_core.Signal<AXPCompareViewField[]>;
    remainingObjects: _angular_core.Signal<AXPCompareViewObject[]>;
    /**
     * Check if a field value will change in the next object (to show arrow in current cell)
     */
    protected hasValueChangingToNext(fieldPath: string, currentObjectIndex: number): boolean;
    /**
     * Check if a field value has changed compared to the previous object
     */
    hasValueChangedFromPrevious(fieldPath: string, currentObjectIndex: number): boolean;
    /**
     * Check if a field has unequal values across objects
     */
    hasUnequalValues(fieldPath: string): boolean;
    /**
     * Check if a field has equal values across objects
     */
    hasEqualValues(fieldPath: string): boolean;
    /**
     * Compare two values for equality (deep comparison for objects/arrays)
     */
    private areValuesEqual;
    /**
     * Toggle the show only changes filter
     */
    toggleShowOnlyChanges(): void;
    /**
     * Remove an object from the comparison
     */
    removeObject(objectId: string): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCompareViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPCompareViewComponent, "axp-compare-view", never, { "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface AXPComponentSlotConfig {
    name: string;
    priority?: number;
    component?: Type<any>;
    condition?: ((context?: AXPContextData) => (boolean | Promise<boolean>)) | string;
    features?: string[];
    loadComponent?: () => Type<any> | Promise<Type<any>>;
    options?: AXPOptionsData | (() => AXPOptionsData) | (() => Promise<AXPOptionsData>);
}
interface AXPComponentSlotModuleConfigs {
    [slotName: string]: AXPComponentSlotConfig[];
}
declare abstract class AXPComponentSlot {
    host: any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPComponentSlot, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPComponentSlot, never, never, {}, {}, never, never, true, never>;
}

declare class AXPComponentSlotDirective implements OnInit {
    name: _angular_core.InputSignal<string>;
    host: _angular_core.InputSignal<any>;
    context: _angular_core.InputSignal<any>;
    private elementRef;
    private registryService;
    private injector;
    private evaluator;
    private sessionService;
    viewContainerRef: ViewContainerRef;
    contextStore: {
        data: _angular_core.Signal<AXPContextData>;
        state: _angular_core.Signal<_acorex_platform_core.AXPContextState>;
        initialSnapshot: _angular_core.Signal<{}>;
        previousSnapshot: _angular_core.Signal<{}>;
        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_core.AXPContextChangeEvent>;
        isChanged: _angular_core.Signal<boolean>;
        isReset: _angular_core.Signal<boolean>;
        isInitiated: _angular_core.Signal<boolean>;
        isEmpty: _angular_core.Signal<boolean>;
        isDirty: _angular_core.Signal<boolean>;
        snapshot: _angular_core.Signal<AXPContextData>;
        initial: _angular_core.Signal<{}>;
        previous: _angular_core.Signal<{}>;
        changeEvent: _angular_core.Signal<_acorex_platform_core.AXPContextChangeEvent>;
        update: (path: string, value: any) => void;
        patch: (context: {}) => void;
        reset: () => void;
        set: (initialData: any) => void;
        getValue: (path: string) => any;
    } & _ngrx_signals.StateSource<{
        data: AXPContextData;
        state: _acorex_platform_core.AXPContextState;
        initialSnapshot: {};
        previousSnapshot: {};
        lastChange: _acorex_platform_core.AXPContextChangeEvent;
    }>;
    isEmpty: _angular_core.Signal<boolean>;
    private _viewCount;
    private componentRefs;
    private placeholderRefs;
    constructor();
    ngOnInit(): Promise<void>;
    loadComponents(): Promise<void>;
    private evaluateCondition;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPComponentSlotDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPComponentSlotDirective, "axp-component-slot", ["slot"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "host": { "alias": "host"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class AXPComponentSlotRegistryService {
    private registry;
    register(slotName: string, config: AXPComponentSlotConfig): void;
    get(slotName: string): AXPComponentSlotConfig[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPComponentSlotRegistryService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPComponentSlotRegistryService>;
}

declare class AXPComponentSlotModule {
    static forRoot(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
    static forChild(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
    /**
     * @ignore
     */
    constructor(instances: any[]);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPComponentSlotModule, [{ optional: true; }]>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXPComponentSlotModule, [typeof AXPComponentSlotDirective], never, [typeof AXPComponentSlotDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPComponentSlotModule>;
}

interface AXPDataSelectorColumn {
    name: string;
    title: string;
    visible: boolean;
    dataPath?: string;
    width?: string;
    widget: {
        type: string;
        options: any;
    };
}
interface AXPDataSelectorConfig {
    title: string;
    dataSource: AXDataSource<any>;
    columns: AXPDataSelectorColumn[];
    selectionMode: 'single' | 'multiple';
    searchFields?: {
        name: string;
        title: string;
    }[];
    initialSearchTerm?: string;
    parentField?: string;
    allowCreate?: boolean;
    filters?: AXDataSourceFilterOption;
    selectedItemIds?: string[] | number[];
    categoryFilter?: {
        enabled: boolean;
        title: string;
        dataSource: AXPCategoryTreeDataSource;
        filterField: string;
        filterOperator?: 'equal' | 'contains' | 'in';
        width?: string;
    };
}
declare class AXPDataSelectorComponent extends AXBasePageComponent {
    protected config: _angular_core.WritableSignal<AXPDataSelectorConfig>;
    protected searchTerm: string;
    protected searchPlaceholderText: _angular_core.WritableSignal<string>;
    protected filter: AXDataSourceFilterOption;
    protected grid: _angular_core.Signal<AXDataTableComponent | undefined>;
    protected selectedItems: _angular_core.WritableSignal<any[]>;
    private initialSelectionApplied;
    private userHasInteracted;
    private isApplyingInitialSelection;
    private initialSelectedItems;
    protected activeCategoryFilter: _angular_core.WritableSignal<{
        node: AXPCategoryEntity;
        filterValue: any;
    } | null>;
    private placeholderUpdateToken;
    private initialSearchApplied;
    private readonly translationService;
    constructor();
    protected allowSelect: _angular_core.Signal<boolean>;
    protected selectedCount: _angular_core.Signal<number>;
    protected hasSearch: _angular_core.Signal<boolean | undefined>;
    protected categoryTreeConfig: _angular_core.Signal<{
        textField: string;
        valueField: string;
        showCheckbox: boolean;
        searchable: boolean;
        searchPlaceholder: string;
        emptyStateTitle: string;
        emptyStateDescription: string;
        emptyStateIcon: string;
    }>;
    protected categoryTreeActions: _angular_core.Signal<{
        canCreate: boolean;
        canUpdate: boolean;
        canDelete: boolean;
        canCreateChild: boolean;
    }>;
    protected ngOnInit(): void;
    protected ngAfterViewInit(): Promise<void>;
    protected handleRowDbClick(e: AXDataTableRowDbClick): void;
    protected handleRowClick(e: AXDataTableRowClick): void;
    protected handleSelectedRowsChange(rows: unknown[]): Promise<void>;
    protected handleChangeSearchValue(e: AXValueChangedEvent): void;
    protected handleCreateNewClick(): Promise<void>;
    protected handleCloseClick(): void;
    protected handleSelectClick(): void;
    protected handleExpandRow(row: any): Promise<void>;
    protected handleCategoryFilterClick(node: AXPCategoryEntity): void;
    protected clearCategoryFilter(): void;
    private applySearchFilter;
    private applyFilterAndSort;
    private applyCategoryFilter;
    private updateSearchPlaceholder;
    /**
     * Apply initial selection based on selectedItemIds from config
     * Loads items by IDs using the data source's byKey method, then selects them in the grid
     */
    private applyInitialSelection;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDataSelectorComponent, "axp-data-selector", never, {}, {}, never, never, true, never>;
}

declare class AXPDataSelectorService {
    private readonly popupService;
    private readonly expressionService;
    private readonly columnWidthService;
    /**
     * Open data selector popup
     */
    open(config: AXPDataSelectorConfig): Promise<{
        items: any[];
    } | null>;
    /**
     * Open data selector with category filter
     */
    openWithCategoryFilter(config: Omit<AXPDataSelectorConfig, 'categoryFilter'>, categoryFilterConfig: {
        title: string;
        dataSource: AXPCategoryTreeDataSource;
        filterField: string;
        filterOperator?: 'equal' | 'contains' | 'in';
        width?: string;
    }): Promise<{
        items: any[];
    } | null>;
    /**
     * Apply column width resolution to all columns using the column width service
     */
    private applyColumnWidths;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSelectorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDataSelectorService>;
}

interface AXPDragDropListItem {
    id: string;
    content: string;
    data?: any;
    disabled?: boolean;
    cssClass?: string;
}
interface AXPDragDropListConfig {
    allowReorder?: boolean;
    allowTransfer?: boolean;
}
interface AXPDragDropListDropEvent {
    previousIndex: number;
    currentIndex: number;
    item: AXPDragDropListItem;
    container: any;
    previousContainer?: any;
    isTransfer: boolean;
}

declare class AXPDragDropListComponent {
    items: _angular_core.ModelSignal<AXPDragDropListItem[]>;
    listId: _angular_core.InputSignal<string>;
    dropListGroup: _angular_core.InputSignal<string>;
    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
    emptyMessage: _angular_core.InputSignal<string>;
    disable: _angular_core.InputSignal<boolean>;
    itemClick: _angular_core.OutputEmitterRef<AXPDragDropListItem>;
    dropListDropped: _angular_core.OutputEmitterRef<AXDropListDroppedEvent>;
    onDrop(event: AXDropListDroppedEvent): void;
    onItemClick(item: AXPDragDropListItem): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDragDropListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDragDropListComponent, "axp-drag-drop-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "listId": { "alias": "listId"; "required": false; "isSignal": true; }; "dropListGroup": { "alias": "dropListGroup"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "itemClick": "itemClick"; "dropListDropped": "dropListDropped"; }, never, never, true, never>;
}

declare class AXPQueryFiltersComponent {
    #private;
    protected translate: AXTranslationService;
    protected calendarService: AXCalendarService;
    private filterOperatorMiddleware;
    private settingsService;
    filtersDefinitions: _angular_core.InputSignal<AXPFilterDefinition[]>;
    initialFilters: _angular_core.InputSignal<AXPFilterQuery[]>;
    onFiltersChanged: _angular_core.OutputEmitterRef<AXPFilterQuery[]>;
    protected dateFormat: _angular_core.WritableSignal<string>;
    protected tagBox: _angular_core.Signal<AXTagBoxComponent | undefined>;
    protected widgetRenderer: _angular_core.Signal<AXPWidgetRendererDirective | undefined>;
    tagBoxInput: any;
    listItems: QueryList<any>;
    protected selectedField: _angular_core.WritableSignal<string | null>;
    protected selectedFilters: _angular_core.WritableSignal<AXPFilterDefinition[]>;
    context: _angular_core.WritableSignal<any>;
    protected activeFilter: _angular_core.WritableSignal<AXPFilterDefinition | null>;
    protected asyncTags: _angular_core.WritableSignal<any[]>;
    protected popover: _angular_core.Signal<AXPopoverComponent | undefined>;
    inputValue: _angular_core.WritableSignal<string>;
    inlineFilters: () => AXPFilterDefinition[];
    protected getDisplayValue: (filter: AXPFilterDefinition, val: any) => Promise<any>;
    protected convertIfISOStringDate: (val: string) => string;
    convertQueriesToDefinitions(queries: AXPFilterQuery[]): AXPFilterDefinition[];
    convertQueriesToContext(queries: AXPFilterQuery[]): any;
    filterFields: () => AXPFilterDefinition[];
    ngOnInit(): void;
    handleSelectField(field: AXPFilterDefinition): void;
    handleFieldKeyDown(e: KeyboardEvent, field: AXPFilterDefinition): void;
    onContextChanged(e: AXPWidgetCoreContextChangeEvent): void;
    handleApplyFilter(): void;
    handleButtonKeyDown(e: Event): void;
    handleKeyDown(e: AXHtmlEvent<KeyboardEvent>): void;
    onEnterKeyPressed(e: Event): void;
    handleTagClick(item: any): void;
    handleRemoveTag(e: Event, index: number): void;
    handleSelectFilters(e: AXValueChangedEvent): void;
    handleAddAllInlineFilters(): void;
    protected getActiveOperator(filter: AXPFilterDefinition | null): string | undefined;
    handleSelectInlineFilter(filter: AXPFilterDefinition): void;
    handleInlineFilterKeyDown(e: KeyboardEvent, filter: AXPFilterDefinition): void;
    handlePopoverClosed(e: AXEvent): void;
    protected onPopoverOpened(e: AXEvent): void;
    protected deactivateAllListItems(): void;
    protected handleKeyboardEvent(event: KeyboardEvent): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryFiltersComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryFiltersComponent, "axp-query-filters", never, { "filtersDefinitions": { "alias": "filtersDefinitions"; "required": false; "isSignal": true; }; "initialFilters": { "alias": "initialFilters"; "required": false; "isSignal": true; }; }, { "onFiltersChanged": "onFiltersChanged"; }, never, never, true, never>;
}

declare class AXPImageEditorPopupComponent extends AXBasePageComponent {
    private readonly fileStorage;
    image: _angular_core.InputSignal<Blob>;
    showHistory: _angular_core.InputSignal<boolean>;
    look: _angular_core.InputSignal<"solid" | "outline" | "blank">;
    aspectRatio: _angular_core.InputSignal<string | undefined>;
    private container;
    private blobUrl;
    protected url: _angular_core.WritableSignal<string | null>;
    protected context: _angular_core.WritableSignal<{
        image: Blob | null;
    }>;
    ngOnInit(): Promise<void>;
    handleValueChanged(e: any): void;
    handleSave(): void;
    handleCancel(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPImageEditorPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPImageEditorPopupComponent, "axp-image-editor-popup", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "showHistory": { "alias": "showHistory"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface AXPImageEditorOpenOptions {
    title?: string;
    image: Blob;
    showHistory?: boolean;
    look?: 'solid' | 'outline' | 'blank';
    aspectRatio?: string;
}
declare class AXPImageEditorService {
    private readonly popupService;
    private readonly translate;
    open(options?: AXPImageEditorOpenOptions): Promise<Blob | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPImageEditorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPImageEditorService>;
}

/**
 * Represents a spreadsheet item (row or column header) with id, text, and optional description
 */
interface AXPSpreadsheetItem {
    id: string;
    title: string;
    description?: string;
    /**
     * Optional CSS class for cell styling (e.g., 'ax-bg-success-lightest ax-text-success' for green)
     * Used when this item is used as a cell value to color-code the cell
     * Allows proper control of both background and text colors
     */
    cssClass?: string;
}
/**
 * Represents the value structure for spreadsheet cells
 * Stores only the ID reference to the item in cellOptions
 */
type AXPSpreadsheetCellValue = string | null;
/**
 * Matrix data structure: { [rowId]: { [columnId]: cellValueId } }
 * cellValueId is the ID of an item from cellOptions
 */
type AXPSpreadsheetData = Record<string, Record<string, AXPSpreadsheetCellValue>>;
/**
 * Represents a column definition in the spreadsheet
 */
interface AXPSpreadsheetColumn {
    /**
     * Column identifier (unique name)
     */
    name: string;
    /**
     * Display title for column header
     */
    title: string;
    /**
     * Optional description for column header
     */
    description?: string;
    /**
     * Path to access row property (e.g., 'user.name', 'age')
     * Used to get/set values in row objects
     */
    path: string;
    /**
     * Widget configuration for this column
     * All cells in this column will use this widget
     */
    widget: AXPWidgetNode;
    /**
     * Optional column width
     */
    width?: string;
    /**
     * Column-level readonly override
     */
    readonly?: boolean;
}
/**
 * Spreadsheet row mode
 * - 'fixed': Rows are provided as input, cannot add/remove (like matrix)
 * - 'dynamic': Users can add/remove rows dynamically (like Excel)
 */
type AXPSpreadsheetRowMode = 'fixed' | 'dynamic';
/**
 * Event emitted when a single cell value changes
 */
interface AXPSpreadsheetCellChangeEvent {
    /**
     * Row identifier (name for fixed mode, generated ID for dynamic mode)
     */
    rowId: string;
    /**
     * Column name
     */
    columnName: string;
    /**
     * New cell value (whatever the widget returns)
     */
    value: any;
    /**
     * Full row object after update
     */
    row: Record<string, any>;
}
/**
 * Event emitted when a row is added or removed (dynamic mode only)
 */
interface AXPSpreadsheetRowChangeEvent {
    /**
     * Type of change: 'add' or 'remove'
     */
    type: 'add' | 'remove';
    /**
     * Row identifier
     */
    rowId: string;
    /**
     * Full row object (for 'add' events)
     */
    row?: Record<string, any>;
    /**
     * All rows after the change
     */
    rows: Record<string, any>[];
}
/**
 * Configuration for the spreadsheet component
 */
interface AXPSpreadsheetConfig {
    /**
     * Widget configuration for cell editing (SelectBox)
     */
    cellWidget?: AXPWidgetNode;
    /**
     * Whether the spreadsheet is in readonly mode
     */
    readonly?: boolean;
    /**
     * Placeholder text for empty cells
     */
    emptyCellPlaceholder?: string;
}

declare class AXPSpreadsheetComponent {
    protected readonly translationService: AXTranslationService;
    /**
     * Translated column titles
     */
    protected translatedColumnTitles: _angular_core.WritableSignal<Map<string, string>>;
    /**
     * Title for the spreadsheet (displayed in corner cell)
     */
    title: _angular_core.InputSignal<string>;
    /**
     * Column definitions
     */
    columns: _angular_core.InputSignal<AXPSpreadsheetColumn[]>;
    /**
     * Row mode: 'fixed' or 'dynamic'
     */
    rowMode: _angular_core.InputSignal<AXPSpreadsheetRowMode>;
    /**
     * Rows data (for fixed mode - input only)
     * Each row must have a 'name' property for identification
     */
    rowsInput: _angular_core.InputSignal<Record<string, any>[]>;
    /**
     * Rows data (for dynamic mode - two-way binding)
     */
    rowsModel: _angular_core.ModelSignal<Record<string, any>[]>;
    /**
     * Whether the spreadsheet is in readonly mode
     */
    readonly: _angular_core.InputSignal<boolean>;
    /**
     * Placeholder text for empty cells (default: "–")
     */
    emptyCellPlaceholder: _angular_core.InputSignal<string>;
    /**
     * Path to property in row object to display as row header title
     * Example: 'name', 'title', 'user.name'
     */
    rowTitlePath: _angular_core.InputSignal<string | null>;
    /**
     * Path to property in row object to display as row header description
     * Example: 'description', 'details', 'user.description'
     */
    rowDescriptionPath: _angular_core.InputSignal<string | null>;
    /**
     * Whether to allow adding rows (dynamic mode only, default: true)
     */
    allowAddRows: _angular_core.InputSignal<boolean>;
    /**
     * Whether to allow removing rows (default: true for dynamic mode, false for fixed mode)
     * Can be enabled for fixed mode if needed
     */
    allowRemoveRows: _angular_core.InputSignal<boolean>;
    /**
     * Emitted when a single cell value changes
     */
    cellChange: _angular_core.OutputEmitterRef<AXPSpreadsheetCellChangeEvent>;
    /**
     * Emitted when rows are added or removed (dynamic mode only)
     */
    rowChange: _angular_core.OutputEmitterRef<AXPSpreadsheetRowChangeEvent>;
    /**
     * Emitted when the entire spreadsheet data changes
     */
    spreadsheetChange: _angular_core.OutputEmitterRef<Record<string, any>[]>;
    /**
     * Currently editing cell: { rowId, columnName } | null
     */
    protected editingCell: _angular_core.WritableSignal<{
        rowId: string;
        columnName: string;
    } | null>;
    /**
     * Original value when entering edit mode (for cancel functionality)
     */
    private originalCellValue;
    /**
     * Internal rows state (for fixed mode)
     */
    private internalRows;
    /**
     * Row ID mapping: rowId -> row index (for tracking)
     */
    private rowIdMap;
    /**
     * Cache for widget nodes to prevent re-rendering
     * Key: `${rowIndex}_${columnName}`, Value: AXPWidgetNode
     */
    private widgetNodeCache;
    /**
     * Cache for cell values to detect actual changes
     * Key: `${rowIndex}_${columnName}`, Value: any
     */
    private cellValueCache;
    /**
     * Get current rows based on mode
     */
    protected currentRows: _angular_core.Signal<Record<string, any>[]>;
    /**
     * Context for widgets-container (all rows as an object with rows array)
     * This allows widgets to access their cell via path like: rows[index].column.path
     */
    protected spreadsheetContext: _angular_core.Signal<{
        rows: Record<string, any>[];
    }>;
    /**
     * Get rows with IDs (ensure all rows have identifiers)
     */
    protected rowsWithIds: _angular_core.Signal<{
        rowId: string;
        row: Record<string, any>;
    }[]>;
    /**
     * Check if spreadsheet is completely empty (both columns and rows)
     */
    protected isEmpty: _angular_core.Signal<boolean>;
    /**
     * Check if columns are empty (regardless of rows)
     * When columns are empty, we should show a message about missing columns, not rows
     */
    protected isColumnsEmpty: _angular_core.Signal<boolean>;
    /**
     * Check if only rows are empty (columns exist but no rows)
     */
    protected isRowsEmpty: _angular_core.Signal<boolean>;
    constructor();
    /**
     * Get the value for a specific cell by row index
     */
    protected getCellValue(rowIndex: number, columnName: string): any;
    /**
     * Get row title from row object using rowTitlePath
     */
    protected getRowTitle(row: Record<string, any>, path: string): string;
    /**
     * Get row description from row object using rowDescriptionPath
     */
    protected getRowDescription(row: Record<string, any>, path: string): string;
    /**
     * Get row by ID
     */
    protected getRowById(rowId: string): Record<string, any> | null;
    /**
     * Check if a cell is currently being edited
     */
    protected isCellEditing(rowId: string, columnName: string): boolean;
    /**
     * Check if a column is readonly
     */
    protected isColumnReadonly(column: AXPSpreadsheetColumn): boolean;
    /**
     * Get widget node for a cell with dynamic path based on row index
     * Path format: rows[rowIndex].column.path
     * Uses caching to prevent unnecessary re-renders
     */
    protected getCellWidgetNode(column: AXPSpreadsheetColumn, rowIndex: number): AXPWidgetNode;
    /**
     * Handle cell click to start editing
     */
    protected handleCellClick(rowId: string, columnName: string, event?: MouseEvent): void;
    /**
     * Handle cell value change from widget
     * The widget sets the value at path like rows[index].column.path
     */
    protected handleCellValueChange(rowIndex: number, columnName: string, event: AXPWidgetCoreContextChangeEvent): void;
    /**
     * Handle spreadsheet context change from widgets-container
     * This is called when any widget in the spreadsheet changes
     */
    protected handleSpreadsheetContextChange(event: AXPWidgetCoreContextChangeEvent): void;
    /**
     * Handle blur event to stop editing (when user clicks away from cell)
     */
    protected handleCellBlur(rowId: string, columnName: string): void;
    /**
     * Handle Escape key to cancel editing
     */
    protected handleKeyDown(event: KeyboardEvent): void;
    /**
     * Commit cell edit (save changes and close editing mode)
     */
    protected commitCellEdit(): void;
    /**
     * Cancel cell edit (discard changes and close editing mode - same as escape)
     */
    protected cancelCellEdit(): void;
    /**
     * Handle click outside to stop editing
     */
    protected handleClickOutside(event: MouseEvent): void;
    /**
     * Handle add row (dynamic mode only)
     */
    protected handleAddRow(): void;
    /**
     * Handle remove row (works for both fixed and dynamic modes)
     */
    protected handleRemoveRow(rowId: string, _event: AXClickEvent): void;
    /**
     * Generate unique row ID for dynamic mode
     */
    private generateRowId;
    /**
     * Update rows array (sync internal state)
     */
    private updateRows;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSpreadsheetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSpreadsheetComponent, "axp-spreadsheet", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowMode": { "alias": "rowMode"; "required": false; "isSignal": true; }; "rowsInput": { "alias": "rowsInput"; "required": false; "isSignal": true; }; "rowsModel": { "alias": "rowsModel"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "emptyCellPlaceholder": { "alias": "emptyCellPlaceholder"; "required": false; "isSignal": true; }; "rowTitlePath": { "alias": "rowTitlePath"; "required": false; "isSignal": true; }; "rowDescriptionPath": { "alias": "rowDescriptionPath"; "required": false; "isSignal": true; }; "allowAddRows": { "alias": "allowAddRows"; "required": false; "isSignal": true; }; "allowRemoveRows": { "alias": "allowRemoveRows"; "required": false; "isSignal": true; }; }, { "rowsModel": "rowsModelChange"; "cellChange": "cellChange"; "rowChange": "rowChange"; "spreadsheetChange": "spreadsheetChange"; }, never, never, true, never>;
}

declare class AXPLogoComponent implements OnInit, OnChanges {
    source: any;
    protected logoType: string;
    private platform;
    ngOnInit(): void;
    ngOnChanges(): void;
    protected setLogoType(): void;
    protected setLogoTheme(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLogoComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLogoComponent, "axp-logo", never, { "source": { "alias": "source"; "required": false; }; }, {}, never, never, true, never>;
}

interface AXPPropertyViewerGroup {
    name: string;
    title: string;
    isCollapsed: boolean;
    props: AXPWidgetProperty[];
}
interface AXPPropertyViewerTab {
    name: string;
    title: string;
    groups: AXPPropertyViewerGroup[];
}
interface AXPPropertyViewerChangedEvent {
    values: any;
    mode: 'init' | 'update';
}

declare class AXPPropertyViewerComponent {
    /**
     * List of tabs that should be rendered inside the property viewer.
     */
    tabsInput: _angular_core.InputSignal<AXPPropertyViewerTab[]>;
    /**
     * Determines rendering mode.
     */
    mode: _angular_core.InputSignal<"simple" | "advanced">;
    /**
     * Emits when property context changes.
     */
    onChanged: EventEmitter<AXPPropertyViewerChangedEvent>;
    protected currentTabIndex: WritableSignal<number>;
    protected tabs: _angular_core.Signal<AXPPropertyViewerTab[]>;
    protected groups: _angular_core.Signal<AXPPropertyViewerGroup[]>;
    protected context: WritableSignal<any>;
    /**
     * Per-expression-path override for "use expression" vs "use value" when binding.enabled.
     * Updated when user toggles the ax-switch; otherwise derived from isExpression(valueAtPath).
     */
    protected expressionModeState: WritableSignal<Record<string, boolean>>;
    protected groupCollapsedStates: Map<string, boolean>;
    private readonly expressionEvaluator;
    private readonly popupService;
    constructor();
    /**
     * Replaces the current context with the provided value and emits an init event.
     */
    initializeContext(value: any): void;
    /**
     * Merges the provided value into the current context and emits an update event.
     */
    update(value: any): void;
    /**
     * Handles context changes produced by rendered widgets.
     */
    protected handleContextChange(event: AXPWidgetCoreContextChangeEvent): void;
    /**
     * Handles tab selection changes.
     */
    protected handleTabChange(event: AXTabStripChangedEvent): void;
    /**
     * Stores collapsed state for a group.
     */
    protected handleCollapsedChange(groupName: string, isCollapsed: boolean): void;
    /**
     * Returns the config path used for the binding value (and expression) for a property with binding.enabled.
     */
    protected getExpressionPath(prop: AXPWidgetProperty): string;
    /**
     * True when the property is in "expression" mode: show only the expression editor button, not the widget.
     * Uses expressionModeState when set; otherwise derives from isExpression(valueAtPath).
     */
    protected isExpressionMode(prop: AXPWidgetProperty): boolean;
    /**
     * Returns the default value when switching from expression to value mode.
     * Source of truth is prop.schema.defaultValue (widget.types): plain value, or function (context) => value.
     * A minimal dataType fallback is used only when the schema provides no default.
     */
    private getDefaultValueForProperty;
    /**
     * Updates the expression/value toggle state for a binding-enabled property.
     * When switching to value: resets the value at path to a type-appropriate default so the
     * widget renderer does not receive the expression string (e.g. checkbox gets false, not a string).
     * When switching to expression: sets the value at path to '{{ }}' so the popup opens with
     * a clean expression placeholder instead of the previous literal (e.g. true/false).
     */
    protected setExpressionMode(prop: AXPWidgetProperty, useExpression: boolean): void;
    /**
     * Opens the binding/expression code editor for a property with binding.enabled.
     * Ensures the value passed to the popup is always a string to avoid code-editor crashes.
     */
    protected openBindingEditor(prop: AXPWidgetProperty): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPropertyViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPPropertyViewerComponent, "axp-property-viewer", never, { "tabsInput": { "alias": "tabsInput"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "onChanged": "onChanged"; }, never, never, true, never>;
}

declare class AXPPropertyViewerPopupComponent extends AXBasePageComponent {
    tabs: _angular_core.InputSignal<AXPPropertyViewerTab[]>;
    mode: _angular_core.InputSignal<"simple" | "advanced">;
    context: _angular_core.InputSignal<any>;
    protected readonly propertyViewer: _angular_core.Signal<AXPPropertyViewerComponent | undefined>;
    protected readonly currentValues: _angular_core.WritableSignal<any>;
    protected currentMode: 'init' | 'update';
    constructor();
    protected handlePropertyChanged(event: AXPPropertyViewerChangedEvent): void;
    protected handleCloseClick(): void;
    protected handleApplyClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPropertyViewerPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPPropertyViewerPopupComponent, "axp-property-viewer-popup", never, { "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface AXPPropertyViewerConfig {
    title: string;
    tabs: AXPPropertyViewerTab[];
    context?: any;
    mode?: 'simple' | 'advanced';
    size?: 'sm' | 'md' | 'lg' | 'full';
}
interface AXPPropertyViewerResult {
    values: any;
    mode: 'init' | 'update';
}
declare class AXPPropertyViewerService {
    private readonly popupService;
    /**
     * Open property viewer popup with predefined tabs and context.
     */
    open(config: AXPPropertyViewerConfig): Promise<AXPPropertyViewerResult | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPropertyViewerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPPropertyViewerService>;
}

declare class AXPQuerySortsComponent {
    sortDefinitions: _angular_core.ModelSignal<AXPSortDefinition[]>;
    sortQueries: _angular_core.WritableSignal<AXPSortQuery[]>;
    initialSortQueries: _angular_core.InputSignal<AXPSortQuery[]>;
    sortQueriesChange: _angular_core.OutputEmitterRef<AXPSortQuery[]>;
    constructor();
    protected drop(event: CdkDragDrop<unknown[]>): void;
    getSortDirection(item: AXPSortDefinition): "desc" | "asc" | undefined;
    protected changeItemSort(item: AXPSortDefinition): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQuerySortsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQuerySortsComponent, "axp-query-sorts", never, { "sortDefinitions": { "alias": "sortDefinitions"; "required": false; "isSignal": true; }; "initialSortQueries": { "alias": "initialSortQueries"; "required": false; "isSignal": true; }; }, { "sortDefinitions": "sortDefinitionsChange"; "sortQueriesChange": "sortQueriesChange"; }, never, never, true, never>;
}

type StateMode = 'empty' | 'error' | 'loading' | 'warning' | 'info' | 'success';
declare class AXPStateMessageComponent {
    mode: _angular_core.InputSignal<StateMode>;
    icon: _angular_core.InputSignal<string>;
    title: _angular_core.InputSignal<string>;
    description: _angular_core.InputSignal<string>;
    variant: _angular_core.InputSignal<"default" | "compact" | "minimal">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStateMessageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStateMessageComponent, "axp-state-message", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[slot=actions]"], true, never>;
}

declare class AXPStopwatchComponent implements OnDestroy {
    mode: _angular_core.InputSignal<"count-up" | "count-down">;
    timeLimit: _angular_core.InputSignal<number | undefined>;
    format: _angular_core.InputSignal<"hh:mm:ss" | "mm:ss" | "ss">;
    autoStart: _angular_core.InputSignal<boolean>;
    showControls: _angular_core.InputSignal<boolean>;
    value: _angular_core.InputSignal<number>;
    valueChange: _angular_core.OutputEmitterRef<number>;
    timeUp: _angular_core.OutputEmitterRef<void>;
    private readonly currentTime;
    protected readonly isRunning: _angular_core.WritableSignal<boolean>;
    private intervalId;
    protected readonly isTimeUp: _angular_core.Signal<boolean>;
    protected readonly displayTime: _angular_core.Signal<string>;
    constructor();
    ngOnDestroy(): void;
    start(): void;
    pause(): void;
    reset(): void;
    private stop;
    private onTimeUp;
    private formatTime;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStopwatchComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStopwatchComponent, "axp-stopwatch", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "timeLimit": { "alias": "timeLimit"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "autoStart": { "alias": "autoStart"; "required": false; "isSignal": true; }; "showControls": { "alias": "showControls"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "timeUp": "timeUp"; }, never, never, true, never>;
}

interface AXPTemplateViewerConfig {
    template: AXPWidgetNode | string;
    title?: string;
    size?: AXPopupSizeType;
    context?: any;
    metadata?: AXPMetaData;
    readOnly?: boolean;
    showActions?: boolean;
}
interface AXPTemplateViewerResult {
    context: any;
    cancelled: boolean;
    metadata?: AXPMetaData;
}

declare class AXPTemplateViewerComponent extends AXBasePageComponent {
    set config(value: AXPTemplateViewerConfig | undefined);
    get config(): AXPTemplateViewerConfig | undefined;
    protected context: any;
    protected readonly document: _angular_core.WritableSignal<AXPWidgetNode>;
    protected readonly currentPageIndex: _angular_core.WritableSignal<number>;
    protected readonly _config: _angular_core.WritableSignal<AXPTemplateViewerConfig | undefined>;
    protected readonly currentPage: _angular_core.Signal<AXPWidgetNode>;
    protected ngOnInit(): Promise<void>;
    private loadTemplate;
    protected handleContextChanged(e: AXPWidgetCoreContextChangeEvent): void;
    protected handleSubmit(form: AXFormComponent): Promise<void>;
    protected handleCancel(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTemplateViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTemplateViewerComponent, "axp-template-viewer", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AXPTemplateViewerService {
    private readonly popupService;
    /**
     * Show a template viewer dialog with the given configuration
     * @param config Template viewer configuration including template, title, and UI options
     * @returns Promise resolving to viewer result with form values and cancellation status
     */
    showTemplate(config: AXPTemplateViewerConfig): Promise<AXPTemplateViewerResult>;
    /**
     * Show a template viewer in read-only mode
     * @param config Template viewer configuration
     * @returns Promise resolving to viewer result
     */
    showTemplateReadOnly(config: Omit<AXPTemplateViewerConfig, 'readOnly' | 'showActions'>): Promise<AXPTemplateViewerResult>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTemplateViewerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTemplateViewerService>;
}

type AXPUserAvatarSize = 'small' | 'medium' | 'large';
type AXPUserAvatarStatus = 'online' | 'offline';
type AXPUserAvatarData = {
    id: string;
    status: AXPUserAvatarStatus;
    username: string;
    firstName: string;
    lastName?: string;
    avatarUrl?: string;
};
interface AXPUserAvatarProvider {
    provide(userId: string): Promise<AXPUserAvatarData>;
}

declare class AXPUserAvatarService {
    private provider;
    private readonly cacheExpiryTime;
    private readonly refreshInterval;
    private cache;
    /**
     * Gets user information with caching and auto-refresh
     * @param userId The username to fetch information for
     * @returns Observable that emits user avatar data
     */
    getUserInfo$(userId: string): Observable<AXPUserAvatarData>;
    /**
     * Gets user information (Promise-based for backward compatibility)
     * @param userId The username to fetch information for
     * @returns Promise that resolves to user avatar data
     */
    getUserInfo(userId: string): Promise<AXPUserAvatarData>;
    /**
     * Clears the entire cache or a specific user's cache
     * @param userId Optional username to clear specific cache
     */
    clearCache(userId?: string): void;
    /**
     * Force refresh data for a specific username
     * @param userId The username to refresh
     * @returns Promise that resolves to the refreshed data
     */
    refreshUserInfo(userId: string): Promise<AXPUserAvatarData>;
    /**
     * Checks if a cache entry is expired
     */
    private isExpired;
    /**
     * Fetches data from provider and updates the cache
     */
    private fetchAndUpdateCache;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPUserAvatarService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPUserAvatarService>;
}

declare const AXP_USER_AVATAR_PROVIDER: InjectionToken<AXPUserAvatarProvider>;

declare class AXPUserAvatarComponent implements OnInit, OnDestroy {
    private readonly userAvatarService;
    private readonly destroy$;
    protected userInfo: _angular_core.WritableSignal<AXPUserAvatarData | null>;
    size: _angular_core.InputSignal<number>;
    userId: _angular_core.InputSignal<string>;
    src: _angular_core.WritableSignal<string>;
    userName: _angular_core.Signal<string>;
    firstName: _angular_core.Signal<string>;
    lastName: _angular_core.Signal<string>;
    title: _angular_core.Signal<string>;
    isOnline: _angular_core.Signal<boolean>;
    avatarText: _angular_core.Signal<string>;
    avatarColor: _angular_core.Signal<string>;
    protected hasAvatar: _angular_core.Signal<boolean>;
    protected isAvatarLoaded: _angular_core.WritableSignal<boolean>;
    protected isLoading: _angular_core.Signal<boolean>;
    protected onImageError(event: AXHtmlEvent<ErrorEvent>): void;
    protected onImageLoad(event: AXHtmlEvent<Event>): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private loadUserData;
    /**
     * Generate avatar image source
     * This is a placeholder - implement based on your actual requirements
     */
    private generateAvatarSrc;
    /**
     * Get initials from first and last name
     */
    private getInitials;
    private hashString;
    private pickColor;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPUserAvatarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPUserAvatarComponent, "axp-user-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "userId": { "alias": "userId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AXPQueryViewsComponent {
    #private;
    protected popupService: AXPopupService;
    protected translate: AXTranslationService;
    protected tabs: _angular_core.Signal<AXTabsComponent | undefined>;
    views: _angular_core.ModelSignal<AXPViewQuery[]>;
    selectedView: _angular_core.ModelSignal<AXPViewQuery>;
    protected isMounted: _angular_core.WritableSignal<boolean>;
    ngAfterViewInit(): void;
    setView(view: AXPViewQuery): void;
    handleActiveChange(e: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryViewsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryViewsComponent, "axp-query-views", never, { "views": { "alias": "views"; "required": false; "isSignal": true; }; "selectedView": { "alias": "selectedView"; "required": true; "isSignal": true; }; }, { "views": "viewsChange"; "selectedView": "selectedViewChange"; }, never, never, true, never>;
}

/**
 * Compact widget field configurator component
 * Designed to be embedded in entity definition forms for configuring widget properties
 */
declare class AXPWidgetFieldConfiguratorComponent {
    /**
     * Widget node configuration (two-way binding)
     */
    widget: _angular_core.ModelSignal<AXPWidgetNode>;
    /**
     * Label for the widget selector
     */
    label: _angular_core.InputSignal<string>;
    /**
     * Field name (technical identifier, used for form field path)
     */
    fieldName: _angular_core.InputSignal<string>;
    /**
     * Field title (display name, used in UI labels and titles)
     */
    fieldTitle: _angular_core.InputSignal<string>;
    /**
     * Readonly mode
     */
    readonly: _angular_core.InputSignal<boolean>;
    private readonly widgetRegistry;
    private readonly widgetPropertyViewerService;
    private readonly translationService;
    private readonly formBuilderService;
    /**
     * Currently selected widget type
     */
    protected selectedWidgetType: _angular_core.WritableSignal<string>;
    /**
     * Whether the component is in edit mode (showing select box)
     */
    protected isEditMode: _angular_core.WritableSignal<boolean>;
    /**
     * Available widgets filtered by FormElement group
     */
    protected availableWidgets: _angular_core.Signal<{
        value: string;
        text: string;
        icon: string | undefined;
        description: string | undefined;
    }[]>;
    /**
     * Current widget configuration details
     */
    protected currentWidgetConfig: _angular_core.Signal<{
        title: string;
        description: string | undefined;
        icon: string | undefined;
        hasProperties: boolean | undefined;
    } | null>;
    /**
     * Whether configure button should be enabled
     */
    protected canConfigure: _angular_core.Signal<boolean>;
    /**
     * Whether widget has been configured (has options)
     */
    protected isConfigured: _angular_core.Signal<boolean>;
    /**
     * Whether preview button should be enabled
     */
    protected canPreview: _angular_core.Signal<boolean>;
    /**
     * Enter edit mode (show select box)
     */
    protected enterEditMode(): void;
    constructor();
    /**
     * Handle widget type change
     */
    protected onWidgetTypeChange(event: any): Promise<void>;
    /**
     * Open widget property viewer
     */
    protected openPropertyViewer(): Promise<void>;
    /**
     * Open widget preview with actual rendered widget
     */
    protected openPreview(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetFieldConfiguratorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetFieldConfiguratorComponent, "axp-widget-field-configurator", never, { "widget": { "alias": "widget"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fieldName": { "alias": "fieldName"; "required": false; "isSignal": true; }; "fieldTitle": { "alias": "fieldTitle"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "widget": "widgetChange"; }, never, never, true, never>;
}

/**
 * Generic interface for widget item data
 */
interface AXPWidgetItemData {
    /** Display title of the widget */
    title: string;
    /** Description text for the widget */
    description?: string;
    /** Icon class (e.g., FontAwesome classes) */
    icon?: string;
    /** Whether the widget is pinned/favorited */
    isPinned: boolean;
    /** Generic data payload - can be any type based on use case */
    data?: unknown;
}
/**
 * Event data for widget item interactions
 */
interface AXPWidgetItemClickEvent<T = unknown> {
    /** The mouse event */
    event: MouseEvent;
    /** The widget item data */
    widget: AXPWidgetItemData & {
        data?: T;
    };
}

/**
 * Generic widget item component for displaying selectable widgets with icons, titles, and descriptions.
 * Can be used across different modules for consistent widget display and interaction.
 */
declare class AXPWidgetItemComponent {
    /** The widget data to display */
    widget: _angular_core.InputSignal<AXPWidgetItemData>;
    /** Whether this widget is currently selected */
    isSelected: _angular_core.InputSignal<boolean>;
    /** Whether to show the pin button */
    showPinButton: _angular_core.InputSignal<boolean>;
    /** Custom CSS classes to apply to the widget item */
    customClasses: _angular_core.InputSignal<string>;
    /** Emitted when the widget item is clicked */
    onWidgetClick: _angular_core.OutputEmitterRef<AXPWidgetItemClickEvent<unknown>>;
    /** Emitted when the pin button is clicked */
    onPinClick: _angular_core.OutputEmitterRef<AXPWidgetItemClickEvent<unknown>>;
    /**
     * Handle widget item click event
     */
    handleClick(event: MouseEvent): void;
    /**
     * Handle pin button click event
     */
    handlePinClick(event: MouseEvent): void;
    /**
     * Get the effective icon to display
     */
    getIconClass(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetItemComponent, "axp-widget-item", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "showPinButton": { "alias": "showPinButton"; "required": false; "isSignal": true; }; "customClasses": { "alias": "customClasses"; "required": false; "isSignal": true; }; }, { "onWidgetClick": "onWidgetClick"; "onPinClick": "onPinClick"; }, never, never, true, never>;
}

interface AXPWidgetPropertiesChangedEvent {
    values: any;
    mode: 'init' | 'update';
}
declare class AXPWidgetPropertyViewerComponent {
    widget: _angular_core.InputSignal<AXPWidgetNode>;
    mode: _angular_core.InputSignal<"simple" | "advanced">;
    onChanged: EventEmitter<AXPWidgetPropertiesChangedEvent>;
    protected readonly propertyViewerRef: _angular_core.Signal<AXPPropertyViewerComponent | undefined>;
    protected readonly config: _angular_core.WritableSignal<AXPWidgetConfig<any> | null>;
    protected readonly tabs: _angular_core.WritableSignal<AXPPropertyViewerTab[]>;
    protected initialContext: Record<string, unknown>;
    protected groupCollapsedStates: Map<string, boolean>;
    /** When true, the next onChanged from the inner viewer was caused by our update(); do not forward to avoid loop. */
    private suppressNextEmit;
    private readonly widgetRegistryService;
    constructor();
    /**
     * Merges the given values into the property viewer context. Called by the designer when applying changes (e.g. undo/redo).
     * The inner viewer will emit onChanged; we ignore that emission to avoid designer -> update -> emit -> designer loop.
     */
    update(values: any): void;
    private fillTabs;
    protected handlePropertyViewerChanged(ev: AXPPropertyViewerChangedEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetPropertyViewerComponent, "axp-widget-property-viewer", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "onChanged": "onChanged"; }, never, never, true, never>;
}

declare class AXPWidgetPropertyViewerPopupComponent extends AXBasePageComponent {
    widget: _angular_core.InputSignal<AXPWidgetNode>;
    mode: _angular_core.InputSignal<"simple" | "advanced">;
    protected currentValues: _angular_core.WritableSignal<any>;
    protected handlePropertyChanged(event: {
        values: any;
        mode: 'init' | 'update';
    }): void;
    protected handleCloseClick(): void;
    protected handleApplyClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetPropertyViewerPopupComponent, "axp-widget-property-viewer-popup", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface AXPWidgetPropertyInjection {
    property: AXPWidgetProperty;
    tab?: {
        name?: string;
        title?: string;
    };
    group?: {
        name?: string;
        title?: string;
    };
}
interface AXPWidgetPropertyViewerConfig {
    title: string;
    widget: AXPWidgetNode;
    mode?: 'simple' | 'advanced';
    /**
     * Property names to exclude from the viewer.
     */
    exclude?: string[];
    /**
     * Custom property injection configuration.
     */
    custom?: {
        /**
         * Custom property injection entries.
         */
        properties: AXPWidgetPropertyInjection[];
        /**
         * Default tab fallback if property injection doesn't specify one.
         * When omitted, falls back to the first tab or "general".
         */
        defaultTab?: {
            name?: string;
            title?: string;
        };
        /**
         * Default group fallback when injection doesn't specify a group.
         * When omitted, falls back to the tab's first group or property defined group.
         */
        defaultGroup?: {
            name?: string;
            title?: string;
        };
    };
}
interface AXPWidgetPropertyViewerResult {
    values: any;
    mode: 'init' | 'update';
}
declare class AXPWidgetPropertyViewerService {
    private readonly widgetRegistryService;
    private readonly propertyViewerService;
    /**
     * Open widget property viewer popup
     */
    open(config: AXPWidgetPropertyViewerConfig): Promise<AXPWidgetPropertyViewerResult | null>;
    private buildTabs;
    private buildInitialContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWidgetPropertyViewerService>;
}

export { AXPActivityLogComponent, AXPCategoryTreeComponent, AXPColorPalettePickerComponent, AXPColumnItemListComponent, AXPCompareViewComponent, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPDataSelectorComponent, AXPDataSelectorService, AXPDragDropListComponent, AXPImageEditorPopupComponent, AXPImageEditorService, AXPLogoComponent, AXPMenuBadgeHelper, AXPPropertyViewerComponent, AXPPropertyViewerPopupComponent, AXPPropertyViewerService, AXPQueryColumnsComponent, AXPQueryFiltersComponent, AXPQuerySortsComponent, AXPQueryViewsComponent, AXPSpreadsheetComponent, AXPStateMessageComponent, AXPStopwatchComponent, AXPTaskBadgeDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPTemplateViewerComponent, AXPTemplateViewerService, AXPThemeLayoutActionsComponent, AXPThemeLayoutBlockComponent, AXPThemeLayoutContainerComponent, AXPThemeLayoutEndSideComponent, AXPThemeLayoutFooterComponent, AXPThemeLayoutHeaderComponent, AXPThemeLayoutListComponent, AXPThemeLayoutListItemComponent, AXPThemeLayoutListItemsGroupComponent, AXPThemeLayoutPageHeaderComponent, AXPThemeLayoutPagePrimaryActionsComponent, AXPThemeLayoutPageSecondaryActionsComponent, AXPThemeLayoutSectionComponent, AXPThemeLayoutStartSideComponent, AXPThemeLayoutToolbarComponent, AXPUserAvatarComponent, AXPUserAvatarService, AXPWidgetFieldConfiguratorComponent, AXPWidgetItemComponent, AXPWidgetPropertyViewerComponent, AXPWidgetPropertyViewerPopupComponent, AXPWidgetPropertyViewerService, AXP_TASK_BADGE_PROVIDERS, AXP_USER_AVATAR_PROVIDER };
export type { AXPCategoryTreeActions, AXPCategoryTreeConfig, AXPCategoryTreeDataSource, AXPCategoryTreeEvents, AXPCategoryTreeNode, AXPColumnItemListItem, AXPCompareViewField, AXPCompareViewInputs, AXPCompareViewMode, AXPCompareViewObject, AXPComponentSlotConfig, AXPComponentSlotModuleConfigs, AXPDataSelectorColumn, AXPDataSelectorConfig, AXPDragDropListConfig, AXPDragDropListDropEvent, AXPDragDropListItem, AXPImageEditorOpenOptions, AXPPropertyViewerChangedEvent, AXPPropertyViewerConfig, AXPPropertyViewerGroup, AXPPropertyViewerResult, AXPPropertyViewerTab, AXPSpreadsheetCellChangeEvent, AXPSpreadsheetCellValue, AXPSpreadsheetColumn, AXPSpreadsheetConfig, AXPSpreadsheetData, AXPSpreadsheetItem, AXPSpreadsheetRowChangeEvent, AXPSpreadsheetRowMode, AXPTemplateViewerConfig, AXPTemplateViewerResult, AXPUserAvatarData, AXPUserAvatarProvider, AXPUserAvatarSize, AXPUserAvatarStatus, AXPWidgetItemClickEvent, AXPWidgetItemData, AXPWidgetPropertiesChangedEvent, AXPWidgetPropertyInjection, AXPWidgetPropertyViewerConfig, AXPWidgetPropertyViewerResult, StateMode };
