import * as i0 from '@angular/core';
import { ChangeDetectorRef, ViewContainerRef, EventEmitter, OnDestroy, AfterViewInit, InjectionToken } from '@angular/core';
import { AXUnsubscriber } from '@acorex/core/utils';
import { AXValidationSummary, AXValidationRuleOptions } from '@acorex/core/validation';
import { ControlValueAccessor } from '@angular/forms';
import { DataSource, CollectionViewer } from '@angular/cdk/collections';
import { Subject, Observable } from 'rxjs';
import * as polytype from 'polytype';
import { Observable as Observable$1 } from 'rxjs/internal/Observable';

type AXAnimationEasing = 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'cubic' | 'cubic-in' | 'cubic-out' | 'cubic-in-out';

declare abstract class NXButtonComponent {
    text: i0.ModelSignal<string>;
    toggleableChange: i0.OutputEmitterRef<boolean>;
    selectedChange: i0.OutputEmitterRef<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NXButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NXButtonComponent, "ng-component", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "text": "textChange"; "toggleableChange": "toggleableChange"; "selectedChange": "selectedChange"; }, never, never, true, never>;
}

/**
 * A token that specifies the  color style of component.
 */
type AXStyleColorType = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'default';
declare const AX_STYLE_COLOR_TYPES: AXStyleColorType[];
type AXStyleLookType = 'solid' | 'blank' | 'outline' | 'twotone' | 'flat' | 'fill' | 'link' | 'none';
declare const AX_STYLE_LOOK_TYPES: AXStyleLookType[];
type AXSizeType = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type AXStyleSizeType = `ax-${AXSizeType}`;
type AXLocation = 'bottom-start' | 'bottom-center' | 'bottom-end' | 'top-start' | 'top-center' | 'top-end' | 'center-end' | 'center-start';
declare const AX_LOCATIONS: AXLocation[];
type AXSurfaceType = 'lightest' | 'lighter' | 'light' | 'surface' | 'dark' | 'darker' | 'darkest';

declare abstract class NXColorComponent {
    color: i0.ModelSignal<AXStyleColorType>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NXColorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NXColorComponent, "ng-component", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; }, never, never, true, never>;
}

declare abstract class NXComponent {
    #private;
    protected isRendered: i0.Signal<boolean>;
    get nativeElement(): HTMLElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<NXComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NXComponent>;
}

/**
 *  Base event class
 * @category Events
 */
declare class NXEvent<T extends NXComponent = NXComponent> {
    sender: T;
}
/**
 *  Contains native event
 * @category Events
 */
declare class NXNativeEvent<T extends NXComponent = NXComponent, E extends Event = Event> extends NXEvent<T> {
    nativeEvent: E;
}
/**
 *  Fires each time the user click the element.
 * @category Events
 */
declare class NXClickEvent<T extends NXComponent = NXComponent> extends NXNativeEvent<T, MouseEvent> {
}

declare abstract class NXInteractiveComponent extends NXComponent {
    disabled: i0.ModelSignal<boolean>;
    tabIndex: i0.ModelSignal<number>;
    onFocus: i0.OutputEmitterRef<void>;
    onBlur: i0.OutputEmitterRef<void>;
    focus(): void;
    blur(): void;
    hasFocus(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NXInteractiveComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NXInteractiveComponent, "ng-component", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "tabIndex": "tabIndexChange"; "onFocus": "onFocus"; "onBlur": "onBlur"; }, never, never, true, never>;
}

declare abstract class NXLookComponent {
    look: i0.ModelSignal<AXStyleLookType>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NXLookComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NXLookComponent, "ng-component", never, { "look": { "alias": "look"; "required": false; "isSignal": true; }; }, { "look": "lookChange"; }, never, never, true, never>;
}

declare abstract class NXValueComponent {
    readonly: i0.ModelSignal<boolean>;
    name: i0.ModelSignal<string>;
    value: i0.ModelSignal<unknown>;
    onValueChanged: i0.OutputEmitterRef<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NXValueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NXValueComponent, "ng-component", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "readonly": "readonlyChange"; "name": "nameChange"; "value": "valueChange"; "onValueChanged": "onValueChanged"; }, never, never, true, never>;
}

/**
 * A token that specifies the direction of component.
 */
type AXDirection = 'vertical' | 'horizontal';

/**
 * A token that specifies the orientation of component.
 */
type AXOrientation = 'vertical' | 'horizontal';

type AXPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'end' | 'end-top' | 'end-bottom' | 'start' | 'start-top' | 'start-bottom';
type AXPlacementType = AXConnectedPosition | AXConnectedPosition[] | AXPlacement | AXPlacement[];
declare function convertToPlacement(value: AXPlacementType): AXConnectedPosition[];
interface AXConnectedPosition {
    originX: 'start' | 'center' | 'end';
    originY: 'top' | 'center' | 'bottom';
    overlayX: 'start' | 'center' | 'end';
    overlayY: 'top' | 'center' | 'bottom';
    weight?: number;
    offsetX?: number;
    offsetY?: number;
}
declare const AX_PLACEMENT_TOP: AXConnectedPosition;
declare const AX_PLACEMENT_TOP_START: AXConnectedPosition;
declare const AX_PLACEMENT_TOP_END: AXConnectedPosition;
declare const AX_PLACEMENT_BOTTOM: AXConnectedPosition;
declare const AX_PLACEMENT_BOTTOM_START: AXConnectedPosition;
declare const AX_PLACEMENT_BOTTOM_END: AXConnectedPosition;
declare const AX_PLACEMENT_START: AXConnectedPosition;
declare const AX_PLACEMENT_START_TOP: AXConnectedPosition;
declare const AX_PLACEMENT_START_BOTTOM: AXConnectedPosition;
declare const AX_PLACEMENT_END: AXConnectedPosition;
declare const AX_PLACEMENT_END_TOP: AXConnectedPosition;
declare const AX_PLACEMENT_END_BOTTOM: AXConnectedPosition;
declare const AX_PLACEMENT_MAP: {
    [key: string]: {
        origin: AXConnectedPosition;
        alts?: AXConnectedPosition[];
    };
};

interface AXRange<T> {
    from: T;
    end: T;
}

/**
 * A token that specifies the  selection mode of component.
 */
type AXSelectionMode = 'single' | 'multiple' | 'none';

/**
 *  Contains native event
 * @category Events
 */
declare class AXEvent {
    /**
     *  The sender component
     */
    component: any;
    /**
     *  The root native element
     */
    htmlElement?: HTMLElement;
    isUserInteraction?: boolean;
}
/**
 *  Contains native event
 * @category Events
 */
declare class AXHtmlEvent<E extends Event = Event> extends AXEvent {
    nativeEvent?: E;
}
/**
 *  Contains native event
 * @category Events
 */
declare class AXValueChangedEvent<T = any> extends AXEvent {
    name?: string;
    value?: T;
    oldValue?: T;
}
/**
 *  Contains native event
 * @category Events
 */
declare class AXOptionChangedEvent<T = any> extends AXEvent {
    name?: string;
    newValue?: T;
    oldValue?: T;
}
/**
 *  Fires each time the user click the element.
 * @category Events
 */
declare class AXClickEvent extends AXHtmlEvent<MouseEvent> {
    /**
     *  uses for extra data
     */
    data?: any;
    nativeEvent?: any;
}
/**
 *  Fires each time the user click the element.
 * @category Events
 */
declare class AXButtonClickEvent extends AXClickEvent {
    name: string;
}
/**
 *  Fires each time the user click the element.
 * @category Events
 */
declare class AXItemClickEvent<T = any> extends AXClickEvent {
    name?: string;
    item: T;
}
/**
 *  Fires each time the user select the element.
 * @category Events
 */
declare class AXItemSelectedEvent<T = any> extends AXEvent {
    item: T;
}
/**
 *  Fires each time the component gets focused.
 * @category Events
 */
declare class AXFocusEvent extends AXHtmlEvent<FocusEvent> {
}
/**
 *  Fires each time an item or multiple items selected by the user or value.
 * @category Events
 */
declare class AXSelectionValueChangedEvent extends AXValueChangedEvent<any | any[]> {
    value?: any;
    oldValue?: any;
    selectedKeys?: any[];
    selectedItems?: any[];
}
/**
 *  Contains range start & end values
 * @category Events
 */
declare class AXRangeChangedEvent<T> extends AXEvent {
    /**
     *  The range start value
     */
    start?: T;
    /**
     *  The range end value
     */
    end?: T;
}

type MXComponentOptionChanging<T = any> = {
    name: string;
    value?: T;
};
type MXComponentOptionChanged<T = any> = MXComponentOptionChanging<T>;
type MXComponentSetOption<T> = {
    name: string;
    value?: T;
    afterCallback?: (oldValue?: T, newValue?: T) => void;
    beforeCallback?: (oldValue?: T, newValue?: T) => void;
};
type AXComponentState = 'clear' | 'success' | 'error';
declare abstract class MXBaseComponent {
    private _cdr;
    private _elementRef;
    private _viewRef;
    private _domService;
    private _id;
    get id(): string;
    set id(v: string);
    protected get cdr(): ChangeDetectorRef;
    /**
     * Gets the host HTML element of the component.
     *
     * @returns T - The native DOM element associated with this component.
     */
    getHostElement<T = HTMLElement>(): T;
    protected getViewContainer(): ViewContainerRef;
    protected internalOptionChanging(option: MXComponentOptionChanging): any;
    protected internalOptionChanged(option: MXComponentOptionChanged): void;
    /**
     *  @ignore
     */
    protected ngOnInit(): void;
    /**
     * Fired when an option related to the component changes.
     *
     * @event
     */
    onOptionChanged: EventEmitter<AXOptionChangedEvent>;
    /**
     * Sets a component option with optional lifecycle callbacks.
     *
     * @param option - The option configuration containing the name, value and optional before/after callbacks.
     */
    setOption<T = any>(option: MXComponentSetOption<T>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MXBaseComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MXBaseComponent>;
}

declare class MXInteractiveComponent extends MXBaseComponent {
    /**
     *  @ignore
     */
    protected onTouchedCallback: () => void;
    /**
     * Registers a touched callback function (ControlValueAccessor method).
     *
     * @param fn - The callback function to register.
     */
    registerOnTouched(fn: () => void): void;
    private _touched;
    /**
     * Indicates whether the component has been touched.
     *
     */
    get touched(): boolean;
    /**
     *  @ignore
     */
    protected markAsTouched(): void;
    /**
     * Emits an event whenever the disabled state of the component changes.
     *
     * @event
     */
    disabledChange: EventEmitter<boolean>;
    private _disabled;
    /**
     *  If set to true, it disables the component.
     */
    get disabled(): boolean;
    set disabled(value: boolean);
    /**
     * Sets the disabled state of the component.
     *
     * @param isDisabled - Whether the component should be disabled.
     */
    setDisabledState(isDisabled: boolean): void;
    _tabIndex: number;
    /**
     *  Specifies the tabindex of the component.
     */
    get tabIndex(): number;
    set tabIndex(value: number);
    /**
     *  Fires each time the component gets focused.
     *  @event
     */
    onFocus: EventEmitter<AXFocusEvent>;
    protected emitOnFocusEvent(e?: FocusEvent): void;
    /**
     *  Fires each time the component gets blurred.
     *  @event
     */
    onBlur: EventEmitter<AXFocusEvent>;
    protected emitOnBlurEvent(e?: FocusEvent): void;
    /**
     * Focuses the component.
     */
    focus(): void;
    /**
     * Removes focus from the component.
     */
    blur(): void;
    /**
     * Checks if the component is focused or has any focused element.
     *
     * @returns boolean - True if the component has focus.
     */
    hasFocus(): boolean;
}

declare class MXValueComponent<T = any> extends MXInteractiveComponent implements ControlValueAccessor {
    /**
     *  Fires each time the user press a key.
     *  @event
     */
    onValueChanged: EventEmitter<AXValueChangedEvent<any>>;
    /**
     * @deprecated The event should not be used, use ngModelChange instead
     */
    valueChange: EventEmitter<any>;
    readonlyChange: EventEmitter<boolean>;
    private _readonly;
    /**
     *  If set to true, user cannot change the value of component.
     */
    get readonly(): boolean;
    set readonly(value: boolean);
    private _name;
    get name(): string;
    set name(value: string);
    private _dirty;
    get dirty(): boolean;
    markAsDirty(): void;
    private _isUserInteraction;
    initValue: T;
    defaultValue: T;
    private _value;
    /**
     * @deprecated The property should not be used, use ngModel instead
     */
    get value(): T;
    set value(v: T);
    stateChange: EventEmitter<AXComponentState>;
    private _state;
    get state(): AXComponentState;
    set state(value: AXComponentState);
    protected emitOnValueChangedEvent(oldValue?: any, newValue?: any): void;
    protected internalSetValue(value: any): T;
    protected internalGetValue(value: any): T;
    protected internalValueChanged(value: any): void;
    protected ngOnInit(): void;
    protected ngOnDestroy(): void;
    protected registerValidation(): void;
    protected document: Document;
    protected platformID: Object;
    private validationService;
    validationRulesChange: EventEmitter<AXFormValidationRule[]>;
    private validationRules;
    get isRequired(): boolean;
    /**
     * Adds a validation rule.
     *
     * @param rule - The validation rule to add.
     */
    addValidationRule(rule: AXFormValidationRule): void;
    /**
     * Removes a validation rule.
     *
     * @param ruleToRemove - The validation rule to remove.
     */
    removeValidationRule(ruleToRemove: AXFormValidationRule): void;
    removeValidationRuleByType(type: string): void;
    /**
     * Validates the component.
     *
     * @returns Promise<AXValidationSummary> - Validation result.
     */
    validate(): Promise<AXValidationSummary>;
    protected setState(state: AXComponentState, ...args: any[]): void;
    protected onChangeCallback: (value: T) => void;
    /**
     * Registers a change callback function (ControlValueAccessor method).
     *
     * @param fn - The callback function to register.
     */
    registerOnChange(fn: (value: T) => void): void;
    /**
     * Writes a value to the component (ControlValueAccessor method).
     *
     * @param value - The value to write.
     */
    writeValue(value: T): void;
    /**
     * Commits a value with optional user interaction flag.
     *
     * @param value - The value to commit.
     * @param u - Optional flag indicating if this is a user interaction.
     */
    commitValue(value: T, u?: boolean): void;
    /**
     * Resets the component value.
     *
     * @param e - Optional flag indicating if this is a user interaction.
     */
    reset(e?: boolean): void;
    /**
     * Resets validation errors.
     */
    resetErrors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MXValueComponent<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MXValueComponent<any>>;
}

declare const TAB_META_KEY = "__meta__";
declare class AXComponentCloseEvent extends AXEvent {
    data?: any;
}
declare class AXComponentClosing {
    cancel: boolean;
    data?: any;
}
declare class AXComponentResult {
    sender: any;
    data?: any;
}
interface AXFormValidationRule {
    rule: string;
    disabled: boolean;
    options?: AXValidationRuleOptions;
}
/**
 *  Defines a CSS class—or multiple classes separated by spaces— which are applied to a span element inside the Button. Allows the usage of custom icons after the primary text.
 */
declare class AXComponentClosedPromise extends Promise<AXComponentResult> {
    private closeMethod;
    constructor(executor: (resolve: (value?: AXComponentResult | PromiseLike<AXComponentResult>) => void, reject: (reason?: any) => void) => void);
    close(): void;
}
declare abstract class AXComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXComponent>;
}
declare abstract class AXClosableComponent extends AXComponent {
    abstract close(): void;
    abstract closeAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXClosableComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXClosableComponent>;
}
declare abstract class AXClearableComponent extends AXComponent {
    abstract reset(u: boolean): void;
    abstract get readonly(): boolean;
    abstract get disabled(): boolean;
    abstract get value(): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXClearableComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXClearableComponent>;
}
declare abstract class AXSearchableComponent extends AXComponent {
    abstract search(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXSearchableComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXSearchableComponent>;
}
declare abstract class AXValuableComponent extends AXComponent {
    abstract get isRequired(): boolean;
    validationRulesChange: EventEmitter<AXFormValidationRule[]>;
    abstract get name(): string;
    abstract get value(): unknown;
    abstract onValueChanged: EventEmitter<AXValueChangedEvent<unknown>>;
    abstract commitValue(value: unknown, u: boolean): any;
    abstract addValidationRule(rule: AXFormValidationRule): any;
    abstract removeValidationRule(rule: AXFormValidationRule): any;
    abstract validate(): Promise<AXValidationSummary>;
    abstract reset(e: boolean): void;
    abstract resetErrors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXValuableComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXValuableComponent>;
}
declare abstract class AXFocusableComponent extends AXComponent {
    abstract focus(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXFocusableComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXFocusableComponent>;
}
interface AXPagedComponentInterface {
    goToPage(page: number): any;
    get totalCount(): number;
    get pageSize(): number;
    onPageChanged: EventEmitter<AXValueChangedEvent<number>>;
}
declare abstract class AXPagedComponent extends AXComponent implements AXPagedComponentInterface {
    abstract goToPage(page: number): any;
    abstract get totalCount(): number;
    abstract pageSize: number;
    abstract onPageChanged: EventEmitter<AXValueChangedEvent<number>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPagedComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPagedComponent>;
}
declare abstract class AXAutocompleteParentComponent<T> extends MXValueComponent<T> {
    oldInputEmitValue: T;
    abstract unsubscriber: AXUnsubscriber;
    onKeyDown: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
    onItemSelected: EventEmitter<AXValueChangedEvent<T>>;
    emitOnItemSelected(value: T, isUserInteraction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutocompleteParentComponent<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXAutocompleteParentComponent<any>>;
}

type AXDataSourceOperator = {
    type: 'equal' | 'isNull' | 'isEmpty' | 'lt' | 'lte' | 'gt' | 'gte' | 'startsWith' | 'endsWith' | 'contains' | 'in';
    negative?: boolean;
};
type AXFilterLogic = 'and' | 'or';
type AXSortOrder = 'asc' | 'desc';
type AXDataSourceFilterOption = {
    field?: string;
    value?: unknown;
    operator?: AXDataSourceOperator;
    logic?: AXFilterLogic;
    filters?: AXDataSourceFilterOption[];
};
type AXDataSourceSortOption = {
    field: string;
    dir: 'asc' | 'desc';
};
interface AXDataSourceQuery {
    take: number;
    skip: number;
    filter?: AXDataSourceFilterOption;
    sort: AXDataSourceSortOption[];
}
interface AXDataSourceCallbackResult<T> {
    items: Array<T>;
    total: number;
}
type AXDataSourceLoadCallback<T> = (e: AXDataSourceQuery) => Promise<AXDataSourceCallbackResult<T>>;
type AXDataSourceByKeyCallback<T> = (key: unknown) => Promise<T>;
interface AXDataSourceConfig<T = unknown> {
    key?: string;
    pageSize: number;
    load: AXDataSourceLoadCallback<T>;
    byKey?: AXDataSourceByKeyCallback<T>;
}
interface AXDataSourceChangedEvent<T = unknown> {
    cachedItems: Array<T>;
    items: Array<T>;
    totalCount: number;
    totalPages: number;
    page: number;
}
interface AXDataSourceItemExpandedEvent<T = unknown> {
    expandedItem: T;
    children: Array<T>;
}
declare class AXDataSource<T = unknown> {
    config: AXDataSourceConfig<T>;
    useCache: boolean;
    private _totalCount;
    get totalCount(): number;
    get totalPages(): number;
    get pageSize(): number;
    private _cachedItems;
    get cachedItems(): T[];
    private _items;
    get items(): T[];
    private fetchedPages;
    private _page;
    private _query;
    get query(): AXDataSourceQuery;
    onChanged: Subject<AXDataSourceChangedEvent<T>>;
    onItemExpanded: Subject<AXDataSourceItemExpandedEvent<T>>;
    onItemRefreshChildren: Subject<{
        id: string;
    }>;
    onLoadingChanged: Subject<boolean>;
    private _isLoading;
    get isLoading(): boolean;
    constructor(config: AXDataSourceConfig<T>);
    private load;
    getItemsByFilter(filter: AXDataSourceFilterOption): Promise<AXDataSourceCallbackResult<T>>;
    private setLoadingState;
    setPage(page: number): void;
    setPageSize(pageSize: number): void;
    filter(value: AXDataSourceFilterOption): void;
    sort(...value: AXDataSourceSortOption[]): void;
    clearFilter(): void;
    reset(): void;
    refresh(options?: {
        reset?: boolean;
    }): void;
    find(key: unknown): T | Promise<T>;
}
declare function convertArrayToDataSource<T = unknown>(items: T[], options?: {
    key: string;
    pageSize: number;
}): AXDataSource<T>;
declare function applyDataSourceQuery<T extends Record<string, unknown>>(items: T[], filter: AXDataSourceFilterOption): T[];

interface AXDataListQuery {
    take?: number;
    skip?: number;
    searchQuery?: string;
}
interface AXDataListFetchCallbackResult {
    items: Array<any>;
    total: number;
}
type AXDataListFetchDataCallback = (e: AXDataListQuery) => Promise<AXDataListFetchCallbackResult>;
type AXDataListItems = Array<any> | AXDataListFetchDataCallback;
declare class AXListDataSource<T = unknown> extends DataSource<T> {
    private config;
    private debounceTime;
    private subscription;
    source: AXDataSource<T>;
    private dataStream;
    private _range;
    get range(): {
        start: number;
        end: number;
    };
    /**
     * @ignore
     */
    constructor(config: {
        source: AXDataSource<T>;
        debounceTime?: number;
    });
    connect(collectionViewer: CollectionViewer): Observable<T[]>;
    disconnect(): void;
    private getPageForIndex;
    refresh(): void;
}

interface AXExpandToggleIcons {
    expanded: string;
    collapsed: string;
}

declare class AXResponsiveDirective implements OnDestroy {
    private _elementRef;
    private _observer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXResponsiveDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXResponsiveDirective, "[axResponsive]", never, {}, {}, never, never, true, never>;
}

interface AXScrollPosition {
    scrollHeight: number;
    scrollTop: number;
    clientHeight: number;
}
declare class AXInfiniteScrollerDirective implements AfterViewInit {
    private elm;
    private scrollEvent$;
    private userScrolledDown$;
    private requestOnScroll$;
    scrollCallback: Function;
    immediateCallback: any;
    scrollPercent: number;
    ngAfterViewInit(): void;
    private registerScrollEvent;
    private streamScrollEvents;
    private requestCallbackOnScroll;
    private isUserScrollingDown;
    private isScrollExpectedPercent;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXInfiniteScrollerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInfiniteScrollerDirective, "[axInfiniteScroller]", never, { "scrollCallback": { "alias": "scrollCallback"; "required": false; }; "immediateCallback": { "alias": "immediateCallback"; "required": false; }; "scrollPercent": { "alias": "scrollPercent"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AXAutoFocusDirective implements AfterViewInit {
    private renderer;
    private el;
    _host: AXFocusableComponent;
    autoFocus?: boolean;
    time: number;
    private document;
    private platformID;
    ngAfterViewInit(): void;
    protected doFocus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutoFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXAutoFocusDirective, "[axAutoFocus]", never, { "autoFocus": { "alias": "axAutoFocus"; "required": false; }; "time": { "alias": "axAutoFocusTime"; "required": false; }; }, {}, never, never, true, never>;
}

type AXHotKeyAction = {
    [key: string]: string | Function;
    parmas?: any;
};
declare class AXHotkeyDirective implements AfterViewInit {
    private el;
    _host: AXComponent;
    private hs;
    axHotkey: string | AXHotKeyAction | AXHotKeyAction[];
    private _subs;
    ngAfterViewInit(): void;
    private _addDefaultAction;
    private _addHotKeyAction;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXHotkeyDirective, "[axHotkey]", never, { "axHotkey": { "alias": "axHotkey"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AXCommonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXCommonModule, never, [typeof AXResponsiveDirective, typeof AXInfiniteScrollerDirective, typeof AXAutoFocusDirective, typeof AXHotkeyDirective], [typeof AXResponsiveDirective, typeof AXInfiniteScrollerDirective, typeof AXAutoFocusDirective, typeof AXHotkeyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXCommonModule>;
}

declare class MXColorComponent extends MXBaseComponent {
    colorChange: EventEmitter<AXStyleColorType>;
    private _color;
    /**
     *  Predefined color schemes
     */
    get color(): AXStyleColorType;
    set color(value: AXStyleColorType);
}

declare abstract class MXLookableComponent {
    look: AXStyleLookType;
    static ɵfac: i0.ɵɵFactoryDeclaration<MXLookableComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MXLookableComponent>;
}
declare class MXLookComponent extends MXBaseComponent {
    lookChange: EventEmitter<AXStyleLookType>;
    private _look?;
    /**
     *  Predefined look schemes
     */
    get look(): AXStyleLookType;
    set look(value: AXStyleLookType);
}

declare const MXColorLookComponent_base: polytype.Polytype.ClusteredConstructor<[typeof MXColorComponent, typeof MXLookComponent]>;
declare class MXColorLookComponent extends MXColorLookComponent_base {
}

declare const MXButtonBaseComponent_base: polytype.Polytype.ClusteredConstructor<[typeof MXInteractiveComponent, typeof MXColorLookComponent]>;
declare class MXButtonBaseComponent extends MXButtonBaseComponent_base {
    /**
     * Emits an event when the text associated with the button changes.
     *
     * @event
     */
    textChange: EventEmitter<string>;
    private _text;
    /**
     *  Defines the primary text to show inside the button.
     */
    get text(): string;
    set text(v: string);
    /**
     * Emits an event when the toggleable state of the action sheet changes.
     *
     * @event
     */
    toggleableChange: EventEmitter<boolean>;
    private _toggleable?;
    /**
     *  Provides visual styling that indicates if the Button is active
     */
    get toggleable(): boolean;
    set toggleable(value: boolean);
    /**
     * Emits an event whenever the selection state of the component changes.
     *
     * @event
     */
    selectedChange: EventEmitter<boolean>;
    private _selected?;
    /**
     *  Indicates if the Button is selected or not
     */
    get selected(): boolean;
    set selected(value: boolean);
    /**
     *  @ignore
     */
    constructor();
    /**
     *  @ignore
     */
    protected get cssClasses(): {
        'ax-button-icon': boolean;
        'ax-state-disabled': boolean;
        'ax-state-selected': boolean;
    };
}

declare class MXInputBaseValueComponent<T = string> extends MXValueComponent<T> {
    oldText: string;
    placeholder: string;
    /**
     *  Fires each time the user press a key.
     *  @event
     */
    onKeyDown: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
    /**
     *  Fires each time the user press a key.
     *  @event
     */
    onKeyUp: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
    /**
     *  Fires each time the user press a key.
     *  @event
     */
    onKeyPress: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
    /**
     *  Fires each time the user change the text.
     *  @event
     */
    onTextChanged: EventEmitter<AXValueChangedEvent<string>>;
    protected emitOnKeydownEvent(e: KeyboardEvent): void;
    protected emitOnKeyupEvent(e: KeyboardEvent): void;
    protected emitOnKeypressEvent(e: KeyboardEvent): void;
    protected emitOnTextChanged(value: string, isUserInteraction?: boolean): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MXInputBaseValueComponent<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MXInputBaseValueComponent<any>>;
}

/**
 * Service that manages selection state and caching for selection components
 */
declare class MXSelectionBridgeService {
    /** Array of currently selected items */
    selectedItems: unknown[];
    /** Cache for normalized items keyed by their unique identifier */
    cacheList: Record<string | number, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MXSelectionBridgeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MXSelectionBridgeService>;
}
/**
 * Injection token for the selection bridge service
 */
declare const AX_SELECTION_DATA_TOKEN: InjectionToken<MXSelectionBridgeService>;
/**
 * Type definition for disabled callback function
 */
type DisabledCallback<T> = (event: {
    item: T;
    index: number;
}) => boolean;
/**
 * Type definition for normalized item object
 */
interface NormalizedItem {
    [key: string]: unknown;
    isLoading?: boolean;
}
/**
 * Abstract base component for selection-based value components
 * Provides common functionality for components that support item selection
 */
declare abstract class MXSelectionValueComponent<T = unknown> extends MXValueComponent<unknown> {
    private readonly formatService;
    private readonly dataService;
    /** Callback function to determine if an item should be disabled */
    disabledCallback: DisabledCallback<T>;
    private _valueField;
    /** Field name used to extract the unique value from items */
    get valueField(): string;
    set valueField(value: string);
    private _textField;
    /** Field name used to extract the display text from items */
    get textField(): string;
    set textField(value: string);
    private _textTemplate;
    /** Template string for formatting item display text */
    get textTemplate(): string;
    set textTemplate(value: string);
    private _defaultText;
    /** Text to display when neither textField nor valueField exist on the item */
    get defaultText(): string;
    set defaultText(value: string);
    private _disabledField;
    /** Field name used to determine if an item is disabled */
    get disabledField(): string;
    set disabledField(value: string);
    private _multiple;
    /** Whether multiple items can be selected */
    get multiple(): boolean;
    set multiple(value: boolean);
    /** Gets the currently selected items */
    get selectedItems(): unknown[];
    onItemSelected: EventEmitter<AXItemSelectedEvent>;
    /**
     * Emitted when an item in the list is clicked.
     *
     * @event
     */
    onItemClick: EventEmitter<AXItemClickEvent>;
    /**
     * Abstract method to retrieve an item by its key
     * @param key The unique identifier of the item
     * @returns The item or a Promise that resolves to the item
     */
    abstract getItemByKey(key: unknown): unknown | Promise<unknown>;
    /**
     * Internal method to set and normalize the component value
     * @param value The value to set (can be single item or array)
     * @returns Normalized value based on multiple selection mode
     */
    internalSetValue(value: unknown): unknown;
    /**
     * Override to normalize selected items when value changes
     */
    emitOnValueChangedEvent(oldValue?: unknown, newValue?: unknown): void;
    /**
     * Normalizes a list of items, filtering out null values
     * @param items Array of items to normalize
     * @param findByKey Whether to attempt finding items by key
     * @returns Array of normalized items
     */
    protected normalizeItemsList(items: unknown[], findByKey?: boolean): NormalizedItem[];
    /**
     * Normalizes a single item, handling caching and async loading
     * @param item Item to normalize
     * @param findByKey Whether to attempt finding the item by key
     * @returns Normalized item object
     */
    private normalizeItem;
    /**
     * Handles the normalization logic for items that need property assignment
     */
    private handleItemNormalization;
    /**
     * Handles async item loading with loading state
     */
    private handleAsyncItem;
    /**
     * Assigns value and text properties to the normalized object
     */
    private assignItemProperties;
    /**
     * Creates a consistent cache key for an item
     */
    private createCacheKey;
    /**
     * Normalizes currently selected items and updates the data service
     */
    private _normalizeSelectedItems;
    /**
     * Unselects the specified items from the selection
     * @param items Items to unselect
     */
    unselectItems(...items: T[]): void;
    /**
     * Selects the specified items
     * @param items Items to select
     */
    selectItems(...items: T[]): void;
    /**
     * Toggles the selection state of the specified items
     * @param items Items to toggle
     */
    toggleSelect(...items: T[]): void;
    /**
     * Checks if an item is currently selected
     * @param item Item to check
     * @returns True if the item is selected
     */
    isItemSelected(item: T): boolean;
    /**
     * Checks if an item is disabled
     * @param item Item to check
     * @returns True if the item is disabled
     */
    isItemDisabled(item: T): boolean;
    /**
     * Checks if an item is currently loading
     * @param item Item to check
     * @returns True if the item is loading
     */
    isItemLoading(item: T): boolean;
    /**
     * Gets the display text for an item using template or text field
     * @param item Item to get display text for
     * @returns Formatted display text
     */
    protected getDisplayText(item: T): string;
    /**
     * Gets the value of an item
     * @param item Item to get value from
     * @returns Item value
     */
    protected getValue(item: T): unknown;
    /**
     * Clears the selection cache and selected items
     */
    protected clearSelectionCache(): void;
    /**
     * Clears only the cache while preserving selected items
     */
    protected softClearSelectionCache(): void;
    /**
     * Clears the debouncing cache for specific items to ensure fresh data is displayed
     */
    protected clearItemDebouncingCache(item: T): void;
    /**
     * Forces a refresh of the display when items are loaded asynchronously
     * This should be called when the data source is updated
     */
    protected refreshDisplay(): void;
    /**
     * Refreshes the display for all selected items to ensure consistency
     * This is useful when the data source has been updated
     */
    protected refreshSelectedItemsDisplay(): void;
    /**
     * Forces a refresh of all selected items by clearing their debouncing cache
     * This ensures fresh data is displayed when the data source is updated
     */
    protected forceRefreshSelectedItems(): void;
    /**
     * Asynchronously loads an item by its key and caches the result
     * @param key Key to load item by
     */
    private loadAndCacheItemByKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<MXSelectionValueComponent<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MXSelectionValueComponent<any>>;
}

declare class AXNgModelDelayedValueChangedDirective implements OnDestroy {
    private ngModel;
    axDelayedValueChanged: EventEmitter<any>;
    axDelayTimeChange: EventEmitter<number>;
    private _delayTime;
    get delayTime(): number;
    set delayTime(v: number);
    private subscription;
    ngOnDestroy(): void;
    constructor();
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXNgModelDelayedValueChangedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXNgModelDelayedValueChangedDirective, "[axDelayedValueChanged]", never, { "delayTime": { "alias": "delayTime"; "required": false; }; }, { "axDelayedValueChanged": "axDelayedValueChanged"; "axDelayTimeChange": "axDelayTimeChange"; }, never, never, true, never>;
}

declare class AXInvertedColorDirective {
    color: i0.InputSignal<AXStyleColorType>;
    ref: ViewContainerRef;
    private platformID;
    constructor();
    protected invertColor(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXInvertedColorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInvertedColorDirective, "[axInvertedColor]", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AXRippleDirective implements OnDestroy {
    private el;
    private cdr;
    enabled?: boolean;
    axRippleColor: string;
    ripple: HTMLSpanElement | null;
    private document;
    private platformID;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private onElementClick;
    private createRipple;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXRippleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AXRippleDirective, "[axRipple]", never, { "enabled": { "alias": "axRipple"; "required": false; }; "axRippleColor": { "alias": "axRippleColor"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AXDomService {
    generateElementId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXDomService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXDomService>;
}

type Options = {
    /**
     * element - An html element
     */
    element: any;
    /**
     * keys - string of keys like (Control.f)
     */
    keys: string;
};
declare class AXHotkeysService {
    private eventManager;
    private document;
    defaults: Partial<Options>;
    /**
     * Add shortcut
     *
     *
     * @param options
     * @returns Observable
     *
     */
    addShortcut(options: Partial<Options>): Observable$1<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeysService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXHotkeysService>;
}

export { AXAutoFocusDirective, AXAutocompleteParentComponent, AXButtonClickEvent, AXClearableComponent, AXClickEvent, AXClosableComponent, AXCommonModule, AXComponent, AXComponentCloseEvent, AXComponentClosedPromise, AXComponentClosing, AXComponentResult, AXDataSource, AXDomService, AXEvent, AXFocusEvent, AXFocusableComponent, AXHotkeyDirective, AXHotkeysService, AXHtmlEvent, AXInfiniteScrollerDirective, AXInvertedColorDirective, AXItemClickEvent, AXItemSelectedEvent, AXListDataSource, AXNgModelDelayedValueChangedDirective, AXOptionChangedEvent, AXPagedComponent, AXRangeChangedEvent, AXResponsiveDirective, AXRippleDirective, AXSearchableComponent, AXSelectionValueChangedEvent, AXValuableComponent, AXValueChangedEvent, AX_LOCATIONS, AX_PLACEMENT_BOTTOM, AX_PLACEMENT_BOTTOM_END, AX_PLACEMENT_BOTTOM_START, AX_PLACEMENT_END, AX_PLACEMENT_END_BOTTOM, AX_PLACEMENT_END_TOP, AX_PLACEMENT_MAP, AX_PLACEMENT_START, AX_PLACEMENT_START_BOTTOM, AX_PLACEMENT_START_TOP, AX_PLACEMENT_TOP, AX_PLACEMENT_TOP_END, AX_PLACEMENT_TOP_START, AX_SELECTION_DATA_TOKEN, AX_STYLE_COLOR_TYPES, AX_STYLE_LOOK_TYPES, MXBaseComponent, MXButtonBaseComponent, MXColorComponent, MXColorLookComponent, MXInputBaseValueComponent, MXInteractiveComponent, MXLookComponent, MXLookableComponent, MXSelectionBridgeService, MXSelectionValueComponent, MXValueComponent, NXButtonComponent, NXClickEvent, NXColorComponent, NXComponent, NXEvent, NXInteractiveComponent, NXLookComponent, NXNativeEvent, NXValueComponent, TAB_META_KEY, applyDataSourceQuery, convertArrayToDataSource, convertToPlacement };
export type { AXAnimationEasing, AXComponentState, AXConnectedPosition, AXDataListFetchCallbackResult, AXDataListFetchDataCallback, AXDataListItems, AXDataListQuery, AXDataSourceByKeyCallback, AXDataSourceCallbackResult, AXDataSourceChangedEvent, AXDataSourceConfig, AXDataSourceFilterOption, AXDataSourceItemExpandedEvent, AXDataSourceLoadCallback, AXDataSourceOperator, AXDataSourceQuery, AXDataSourceSortOption, AXDirection, AXExpandToggleIcons, AXFilterLogic, AXFormValidationRule, AXHotKeyAction, AXLocation, AXOrientation, AXPagedComponentInterface, AXPlacement, AXPlacementType, AXRange, AXScrollPosition, AXSelectionMode, AXSizeType, AXSortOrder, AXStyleColorType, AXStyleLookType, AXStyleSizeType, AXSurfaceType, DisabledCallback, MXComponentOptionChanged, MXComponentOptionChanging, MXComponentSetOption, NormalizedItem };