import * as _ibenvandeveire_ngx_layout from '@ibenvandeveire/ngx-layout';
import * as i0 from '@angular/core';
import { ElementRef, Signal, InputSignal, Type, TemplateRef, Injector, EnvironmentInjector, OnInit, AfterContentChecked, AfterViewInit, DestroyRef, WritableSignal, OnDestroy, ChangeDetectorRef, Renderer2, OnChanges, OutputEmitterRef, Provider, ViewContainerRef, ComponentRef, EmbeddedViewRef, PipeTransform } from '@angular/core';
import { CdkDragDrop, CdkDrag, CdkDropList } from '@angular/cdk/drag-drop';
import { FormControl, ControlValueAccessor, FormRecord } from '@angular/forms';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import { MarkerBase as MarkerBase$1 } from 'markerjs-live';
import * as markerjs2 from 'markerjs2';
import { MarkerAreaState, MarkerBase } from 'markerjs2';
import { LiveAnnouncer } from '@angular/cdk/a11y';
import { NgxWindowService } from '@ibenvandeveire/ngx-core';
import { MarkedOptions, Marked, MarkedExtension } from 'marked';
import { CanActivateFn, CanDeactivateFn } from '@angular/router';

type NgxConfigurableLayoutItemSizeOption = 'fit-content' | 'fill' | 'equal';
type NgxConfigurableLayoutType = 'static' | 'editable';
interface NgxConfigurableLayoutItemEntity {
    key: string;
    isActive: boolean;
    disabled?: boolean;
}
type NgxConfigurableLayoutGrid = NgxConfigurableLayoutItemEntity[][];
interface NgxConfigurableLayoutItemDropEvent {
    currentGrid: NgxConfigurableLayoutGrid;
    eventType: 'sorting' | 'moving';
    element: NgxConfigurableLayoutItemEntity;
    showInactive: boolean;
    targetRowIndex: number;
}

/**
 * An abstract class to use when implementing custom fallbacks for the NgxDisplayContentDirective
 */
declare abstract class NgxDisplayContentComponent {
    elementRef: ElementRef;
    /**
     * An optional data input to provide data to the fallback components. This property is typed as any.
     */
    readonly data: i0.InputSignal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDisplayContentComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDisplayContentComponent, never, never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * An abstract directive used as a base to handle focussed base actions
 */
declare abstract class NgxHasFocusDragAndDropAbstractDirective {
    /**
     * Whether the current element is focussed
     */
    protected hasFocus: boolean;
    /**
     * Set the hasFocus flag
     */
    setFocus(): void;
    /**
     * Remove the hasFocus flag
     */
    removeFocus(): void;
    readonly elementRef: ElementRef<HTMLElement>;
    focus(): void;
    onBlur?(): void;
    onFocus?(): void;
    /**
     * Execute an action when the element has focussed
     *
     * @param action - The provided action
     */
    handleWhenFocussed(action: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxHasFocusDragAndDropAbstractDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxHasFocusDragAndDropAbstractDirective, never, never, {}, {}, never, never, true, never>;
}

/**
 * An abstract class to avoid circular dependency with the ItemDirective and the HostDirective
 */
declare abstract class NgxAccessibleAbstractDragAndDropItemDirective extends NgxHasFocusDragAndDropAbstractDirective {
    /**
     * An unique id of the draggable item
     */
    abstract itemId: Signal<string>;
    /**
     *  Marks the item as focussed and selected
     */
    abstract markAsActive(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAccessibleAbstractDragAndDropItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxAccessibleAbstractDragAndDropItemDirective, never, never, {}, {}, never, never, true, never>;
}

/**
 * An abstract service that is used to make drag and drop components accessible for assistive technologies
 */
declare abstract class NgxAccessibleDragAndDropAbstractService {
    /**
     * The live region service
     */
    protected readonly liveRegionService: LiveAnnouncer;
    /**
     * The window service
     */
    protected readonly windowService: NgxWindowService;
    /**
     * A method that passes the current language, can either be a string or an Observable
     */
    abstract get currentLanguage(): string | Observable<string>;
    /**
     * A custom set of messages used for the drag and drop events.
     *
     *  Please check the readme for more information on what is necessary to make these messages accessible.
     */
    customMessages: Record<string, NgxAccessibleDragAndDropMessageRecord>;
    /**
     * Sets a message to the live region
     *
     * @param message - The provided message
     */
    setMessage(message: NgxAccessibleDragAndDropMessage): Observable<void>;
    /**
     * Adds a description to the drag and drop host explaining how the drag and drop functions
     *
     * @param  parent - The drag and drop host
     * @param description - An optional description used to overwrite the default description
     */
    setDragAndDropDescription(parent: HTMLElement, description?: string): Observable<void>;
    /**
     * Returns the custom message record or the default when no custom record was provided
     */
    private get messageRecord();
}

/**
 * An abstract component provided for the NgxTableComponent, allowing to user to set a default open row state template for all tables
 *
 */
declare abstract class NgxTableOpenRowStateTemplateAbstractComponent {
    /**
     * The current open state the component has to visualize
     */
    isOpen: InputSignal<boolean>;
    /**
     * The row data
     */
    row: InputSignal<any>;
    /**
     * The index of the row
     */
    index: InputSignal<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableOpenRowStateTemplateAbstractComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTableOpenRowStateTemplateAbstractComponent, never, never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "row": { "alias": "row"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * An abstract component provided for the NgxTableComponent, allowing to user to set a default select template for all tables
 *
 */
declare abstract class NgxTableSelectTemplateAbstractComponent {
    /**
     * The control we wish to pass to the input
     */
    control: InputSignal<FormControl<any>>;
    /**
     * The row that is visualized
     */
    row: InputSignal<any>;
    /**
     * The index of the row
     */
    index: InputSignal<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableSelectTemplateAbstractComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTableSelectTemplateAbstractComponent, never, never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; "row": { "alias": "row"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare enum NgxTableSortDirection {
    ASCENDING = "ASCENDING",
    DESCENDING = "DESCENDING"
}

/**
 * An abstract component provided for the NgxTableComponent, allowing to user to set a default sort template for all tables
 *
 */
declare abstract class NgxTableSortTemplateAbstractComponent {
    /**
     * The current sort direction the component has to visualize
     */
    direction: InputSignal<NgxTableSortDirection>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableSortTemplateAbstractComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTableSortTemplateAbstractComponent, never, never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type NgxDisplayContentStatus = 'loading' | 'error' | 'offline';
type NgxDisplayContentAriaLive = 'polite' | 'assertive' | 'off';
type NgxDisplayContentRecord<DataType> = Partial<Record<NgxDisplayContentStatus, DataType>>;
type NgxDisplayContentConditions = NgxDisplayContentRecord<boolean>;
type NgxDisplayContentComponentConfiguration = NgxDisplayContentRecord<Type<NgxDisplayContentComponent>>;
type NgxDisplayContentOverrideConfiguration = NgxDisplayContentRecord<{
    template?: TemplateRef<any>;
    data?: any;
}>;
interface NgxDisplayContentConfiguration {
    components: NgxDisplayContentComponentConfiguration;
    hideWhenNoTemplateProvided?: boolean;
    listenToOnlineStatus?: boolean;
}

type NgxAccordionOpenBehavior = 'first' | 'all' | number | number[];
type NgxAccordionOpenStateBehavior = 'all' | 'one';

type NgxAccessibleDragAndDropFromToMessage = `${string}{{#item}}${string}{{#to}}${string}{{#from}}${string}` | `${string}{{#item}}${string}{{#from}}${string}{{#to}}${string}` | `${string}{{#to}}${string}{{#item}}${string}{{#from}}${string}` | `${string}{{#to}}${string}{{#from}}${string}{{#item}}${string}` | `${string}{{#from}}${string}{{#item}}${string}{{#to}}${string}` | `${string}{{#from}}${string}{{#to}}${string}{{#item}}${string}`;
interface NgxAccessibleDragAndDropMessageRecord {
    selected: `${string}{{#item}}${string}`;
    deselected: `${string}{{#item}}${string}`;
    reordered: NgxAccessibleDragAndDropFromToMessage;
    moved: NgxAccessibleDragAndDropFromToMessage;
    cancelled: `${string}{{#item}}${string}`;
    item: string;
    container: string;
    description: string;
}
type NgxAccessibleDragAndDropMoveType = 'reordered' | 'moved';
interface NgxAccessibleDragAndDropBaseMessage<KeyType extends keyof NgxAccessibleDragAndDropMessageRecord, DataType> {
    type: KeyType;
    data: DataType;
}
type NgxAccessibleDragAndDropMessage = NgxAccessibleDragAndDropBaseMessage<'selected' | 'deselected' | 'cancelled', {
    item: string;
    itemLabel?: string;
}> | NgxAccessibleDragAndDropBaseMessage<'reordered' | 'moved', {
    item: string;
    from: string;
    to: string;
    itemLabel?: string;
    toLabel?: string;
    fromLabel?: string;
}>;
interface NgxAccessibleDragAndDropMoveEvent {
    previousIndex: number;
    newIndex: number;
    previousContainer: number;
    newContainer: number;
}

/**
 * The state of the marker view
 */
type NgxImageMarkerState = MarkerAreaState;
/**
 * A marker on the marker view
 */
type NgxImageMarkerItem = MarkerBase;
/**
 * A record with the marker types we wish to show, both for the view and the edit mode
 */
interface NgxImageMarkerTypes {
    edit: (typeof MarkerBase)[];
    view: (typeof MarkerBase$1)[];
}
/**
 * Configuration for the marker view
 */
interface NgxImageMarkerConfiguration {
    /**
     * Whether the record is readonly or not
     */
    mode: 'view' | 'edit';
    /**
     * The state the view has to start from
     */
    defaultState: NgxImageMarkerState;
    /**
     * Whether zooming in is allowed, by default false
     */
    allowZoom?: boolean;
    /**
     * Whether clearing the marker view is allowed, by default false
     */
    allowClear?: boolean;
    /**
     * An optional set of allowed marker types, by default all
     */
    markerTypes?: NgxImageMarkerTypes;
    /**
     * An optional set of allowed marker types, by default the levels are [1,2,3,4] and the current zoom is 1
     */
    zoom?: {
        levels: number[];
        current: number;
    };
}
interface NgxImageMarkerBase {
    mode: 'view' | 'edit';
    close: () => void;
}
interface NgxImageMarkerView extends NgxImageMarkerBase {
    mode: 'view';
    valueChanges: Observable<NgxImageMarkerItem>;
}
interface NgxImageMarkerEdit extends NgxImageMarkerBase {
    mode: 'edit';
    valueChanges: Observable<MarkerAreaState>;
}
/**
 * An Angular wrapper for markerjs views
 */
type NgxImageMarker = NgxImageMarkerEdit | NgxImageMarkerView;

interface NgxTableSortEvent<ColumnKey = string> {
    direction: NgxTableSortDirection;
    column: ColumnKey;
}

type RequireAtLeastOne<DataType> = {
    [Key in keyof DataType]-?: Required<Pick<DataType, Key>> & Partial<Pick<DataType, Exclude<keyof DataType, Key>>>;
}[keyof DataType];

interface NgxTableShowHeaderRequirements {
    isLoading: boolean;
    isEmpty: boolean;
}
interface NgxTableCypressDataTagsBase {
    header?: string;
    cell?: string;
    footer?: string;
}
type NgxTableCypressDataTags = RequireAtLeastOne<NgxTableCypressDataTagsBase>;

type NgxTreeGridRowTarget = 'current' | 'above' | 'below' | 'first' | 'last';
type NgxTreeGridCellTarget = number | 'first' | 'last';

type ComponentType = Type<any> | null;
type NgxMobileLayoutItem = ComponentType | Record<string, ComponentType>;
interface NgxMobileLayoutBase<DataType> {
    /**
     * The header we wish to render
     */
    header: {
        /**
         * The center part of the header we wish to render
         */
        main?: DataType;
        /**
         * The left part of the header we wish to render
         */
        left?: DataType;
        /**
         * The right part of the header we wish to render
         */
        right?: DataType;
    };
    /**
     * An optional flyout we wish to render
     */
    flyout: DataType;
    /**
     * An optional aside we wish to render
     */
    aside: DataType;
    /**
     * An optional navigation we wish to render
     */
    navigation: DataType;
    /**
     * The footer we wish to render
     */
    footer: DataType;
}
/**
 * Parameters configured when opening a component inside a mobile layout outlet (aside or flyout).
 */
interface NgxMobileLayoutOutletParams {
    /**
     * The accessible name (ARIA label) for the dialog or flyout container.
     */
    label: string;
    /**
     * An optional parent injector to use for the instantiated component.
     */
    injector?: Injector;
    /**
     * An optional set of input values to pass to the component.
     */
    inputs?: Record<string, unknown>;
    /**
     * Optional projectable nodes to project into the component.
     */
    content?: Node[][];
    /**
     * An optional environment injector to use for compiling components.
     */
    environmentInjector?: EnvironmentInjector;
}
/**
 * A layout for the `NgxMobileLayoutService`
 */
type NgxMobileLayout = Partial<NgxMobileLayoutBase<ComponentType>>;
/**
 * A layout configuration for the `NgxMobileLayoutService`
 */
type NgxMobileLayoutConfiguration = Partial<NgxMobileLayoutBase<NgxMobileLayoutItem>>;
type NgxMobileLayoutByQuery = NgxMobileLayoutBase<Record<string, ComponentType>>;
/**
 * All possible elements of the mobile layout
 */
type NgxMobileLayoutElements = keyof Omit<NgxMobileLayout, 'header'> | `header.${keyof NgxMobileLayout['header']}`;

/**
 * The priority of the button
 */
type NgxButtonPriority = 'primary' | 'secondary' | 'tertiary' | 'danger' | 'success';
/**
 * The type of the button
 */
type NgxButtonType = 'regular' | 'fab' | 'text' | 'outline';
/**
 * The position of the icon in the button
 */
type NgxButtonIconPosition = 'left' | 'right';
/**
 * The width of the button
 */
type NgxButtonWidth = 'full' | 'fit';
/**
 * Whether the text and icon or only the icon needs to be shown
 */
type NgxButtonDisplayType = 'icon' | 'text' | 'both';
/**
 * The default configuration of the button
 *
 * loading - An optional component used for the loading state
 * icon - An optional component used for the icon
 * iconPosition - The optional default position of the icon, by default `left`
 * labelWrapper - The optional default HTML element used to wrap the button label, by default `span`
 */
interface NgxButtonConfiguration {
    loading?: Type<NgxDisplayContentComponent>;
    icon?: Type<NgxDisplayContentComponent>;
    iconPosition?: NgxButtonIconPosition;
    labelWrapper?: string;
}

interface NgxMediaQuery {
    id: string;
    query: string;
}
type NgxMediaQueryMatchingPredicate = 'every' | 'some';

/**
 * The priority of the link
 */
type NgxLinkPriority = 'primary' | 'secondary' | 'tertiary' | 'danger' | 'success';
/**
 * The position of the icon in the button
 */
type NgxLinkIconPosition = 'left' | 'right';
/**
 * The type of the link
 */
type NgxLinkType = 'text' | 'icon' | 'button';
/**
 * The width of the link
 */
type NgxLinkWidth = 'full' | 'fit';
/**
 * The context of the link
 */
type NgxLinkContext = 'navigation' | 'breadcrumb' | 'anchor' | 'form' | 'footer';
/**
 * Whether the link is an internal link or external link
 */
type NgxLinkDestination = 'internal' | 'external';
/**
 * The default configuration of the link
 *
 * loading - An optional component used for the loading state
 * icon - An optional component used for the icon
 * iconPosition - The optional default position of the icon, by default `left`
 * labelWrapper - The optional default HTML element used to wrap the button link, by default `span`
 */
interface NgxLinkConfiguration {
    loading?: Type<NgxDisplayContentComponent>;
    icon?: Type<NgxDisplayContentComponent>;
    iconPosition?: NgxLinkIconPosition;
    labelWrapper?: string;
}

interface NgxTableAriaLabels {
    /**
     * The ARIA label we wish to set on the select-all checkbox in the table header
     */
    selectAll?: string;
    /**
     * The ARIA label we wish to set on the checkbox/radio button in individual table rows
     */
    selectRow?: string | ((index: number) => string);
    /**
     * The ARIA label we wish to set on the expand row button in individual table rows
     */
    expandRow?: string | ((index: number) => string);
    /**
     * The ARIA label we wish to set on the collapse row button in individual table rows
     */
    collapseRow?: string | ((index: number) => string);
    /**
     * The ARIA label we wish to set on the sort button in individual table headers
     */
    sortColumn?: string | ((column: string, direction: NgxTableSortDirection | null) => string);
    /**
     * The ARIA label we wish to set on the selection column header
     */
    selectionColumn?: string;
    /**
     * The ARIA label we wish to set on the expansion column header
     */
    expansionColumn?: string;
}

/**
 * The layout item pairs with the `<ngx-configurable-layout>` container.
 * This component will in itself not be rendered. The key provided in this component
 * will need to be provided in the `[keys]` input or the `formControl` of the layout container
 * as well. The order in which they are provided there, will define the order in which
 * the items will be rendered.
 */
declare class NgxConfigurableLayoutItemComponent {
    /**
     * The unique key of the layout item.
     */
    readonly key: i0.InputSignal<string>;
    /**
     * An optional label for the layout item used for WCAG purposes.
     */
    readonly label: i0.InputSignal<string>;
    /**
     * The template reference of the;
     */
    readonly template: i0.Signal<TemplateRef<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxConfigurableLayoutItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxConfigurableLayoutItemComponent, "ngx-configurable-layout-item", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * This component acts essentially as a layout wrapper. In combination with the
 * `<ngx-configurable-layout-item>` provided with a key as input, this component allows
 * you to dynamically change the order in which the items get rendered.
 *
 * The order of the items in the template does not matter, it gets set by the `[keys]` input.
 * You may also bind a `FormControl<string[][]>` to this component, which will allow you to reactively
 * change the order in which the elements get rendered. The control will always override the`[keys]` input.
 */
declare class NgxConfigurableLayoutComponent implements ControlValueAccessor, OnInit, AfterContentChecked, AfterViewInit {
    /**
     * A subject to mark the isActiveFormRecord as initialized
     */
    protected readonly isActiveFormRecordInitializedSubject: BehaviorSubject<boolean>;
    /**
     * A subject to hold the destroy flow
     */
    protected readonly destroyRef: DestroyRef;
    /**
     * A list of the configurable item templates.
     */
    readonly configurableItemTemplates: i0.Signal<readonly NgxConfigurableLayoutItemComponent[]>;
    /**
     * An optional template to overwrite the default checkbox
     */
    readonly checkboxTemplate: i0.Signal<TemplateRef<any>>;
    readonly form: FormControl<NgxConfigurableLayoutGrid>;
    readonly isActiveFormRecord: FormRecord<FormControl<boolean>>;
    /**
     * A record of the templates with the unique item `key` and its `templateRef`.
     */
    itemTemplateRecord: WritableSignal<Record<string, TemplateRef<any>>>;
    /**
     * A record of the label with the unique item `key` and its `label`.
     */
    itemLabelRecord: WritableSignal<Record<string, string>>;
    /**
     * Whether the layout is static or editable.
     *
     * If the layout is `static`, a two dimensional array of key strings needs to be provided to the layout through the `keys` input.
     * If the layout is `editable`, a form control needs to be provided to the layout requiring a two dimensional array with {key, isActive} pairs.
     */
    readonly layoutType: InputSignal<NgxConfigurableLayoutType>;
    /**
     * The keys will determine the order of the `ngx-configurable-layout-item` layout items.
     *
     * This property can only be used when the layoutType  is set to `static`.
     */
    keys: InputSignal<string[][]>;
    /**
     * Whether the inactive items should be visible in the layout.
     *
     * This property can only be used when the layoutType is set to `editable`.
     */
    readonly showInactive: InputSignal<boolean>;
    /**
     * Whether drag and drop is enabled for the layout.
     *
     * This property can only be used when the layoutType is set to `editable`
     */
    readonly allowDragAndDrop: InputSignal<boolean>;
    /**
     * Determines how much space each item takes in the row. By default, this is 'fill'
     *
     * fill - Will make the items take up the available space
     * fit-content - Will make the items take up the space of the provided template
     * equal - Will make the items take up equal amount of space throughout the grid
     */
    readonly itemSize: InputSignal<NgxConfigurableLayoutItemSizeOption>;
    /**
     * An optional row gap we can provide to create a gap between the rows of the layout.
     *
     * This input requires an amount in px, rem, %, etc.
     */
    readonly rowGap: InputSignal<string>;
    /**
     * An optional predicate we can use to allow or disallow items to be dropped
     *
     * @memberof NgxConfigurableLayoutComponent
     */
    readonly dropPredicate: InputSignal<(event: NgxConfigurableLayoutItemDropEvent) => boolean>;
    /**
     * An optional label for the layout item used for WCAG purposes.
     */
    readonly itemLabel: InputSignal<string>;
    /**
     * An optional label for the layout item used for WCAG purposes.
     */
    readonly rowLabel: InputSignal<string>;
    /**
     * An optional description explaining how the drag and drop works used for WCAG purposes.
     */
    readonly description: InputSignal<string>;
    /**
     * An optional column gap we can provide to create a gap between the columns of the layout.
     *
     * This input requires an amount in px, rem, %, etc.
     */
    readonly columnGap: InputSignal<string>;
    constructor();
    ngOnInit(): void;
    ngAfterContentChecked(): void;
    ngAfterViewInit(): void;
    /**
     * Callback function for ControlValueAccessor onChange
     */
    protected onChanged: Function;
    /**
     * Callback function for ControlValueAccessor onTouched
     */
    protected onTouched: Function;
    writeValue(value: NgxConfigurableLayoutGrid): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    /**
     * Drag and drop an element in the grid
     *
     * @param {CdkDragDrop<string[]>} event - The grid element
     * @memberof NgxConfigurableLayoutComponent
     */
    drop(event: CdkDragDrop<string[]>): void;
    /**
     * Moves an element based on its provided event
     *
     * @param event - The provided move event
     */
    move(event: NgxAccessibleDragAndDropMoveEvent): void;
    /**
     * The predicate we run before sorting
     *
     * @param  draggedElement - The dragged element
     * @param  list - The list into which we're dragging the element
     */
    beforeSort: (_: number, draggedElement: CdkDrag, list: CdkDropList) => boolean;
    /**
     * The predicate we run before moving
     *
     * @param  draggedElement - The dragged element
     * @param  list - The list into which we're dragging the element
     */
    beforeDrop: (draggedElement: CdkDrag, list: CdkDropList) => boolean;
    /**
     * Handles the drop predicate
     *
     * @protected
     * @param eventType - Whether we're moving or sorting
     * @param draggedElement - The element that's being dragged
     * @param list - The list into which we're dragging the element
     */
    protected dropPredicateHandler(eventType: 'sorting' | 'moving', draggedElement: CdkDrag<NgxConfigurableLayoutItemEntity>, list: CdkDropList): boolean;
    /**
     * Update the item layout template order.
     */
    protected handleItemTemplates(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxConfigurableLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxConfigurableLayoutComponent, "ngx-configurable-layout", never, { "layoutType": { "alias": "layoutType"; "required": true; "isSignal": true; }; "keys": { "alias": "keys"; "required": false; "isSignal": true; }; "showInactive": { "alias": "showInactive"; "required": false; "isSignal": true; }; "allowDragAndDrop": { "alias": "allowDragAndDrop"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "rowGap": { "alias": "rowGap"; "required": false; "isSignal": true; }; "dropPredicate": { "alias": "dropPredicate"; "required": false; "isSignal": true; }; "itemLabel": { "alias": "itemLabel"; "required": false; "isSignal": true; }; "rowLabel": { "alias": "rowLabel"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "columnGap": { "alias": "columnGap"; "required": false; "isSignal": true; }; }, {}, ["configurableItemTemplates", "checkboxTemplate"], never, true, never>;
}

/**
 * A WCAG/ARIA compliant implementation of an item in the accordion pattern.
 *
 * https://www.w3.org/WAI/ARIA/apg/patterns/accordion/
 */
declare class NgxAccordionItemComponent implements OnInit, AfterViewInit, OnDestroy {
    /**
     * An instance of the parent NgxAccordionComponent
     */
    protected readonly parent: NgxAccordionComponent;
    /**
     * An instance of the ChangeDetectorRef
     */
    protected readonly cdRef: ChangeDetectorRef;
    /**
     * An instance of the Renderer2
     */
    protected readonly renderer: Renderer2;
    /**
     * The details element
     */
    readonly detailsElement: i0.Signal<ElementRef<any>>;
    /**
     * The summary element
     */
    readonly summaryElement: i0.Signal<ElementRef<any>>;
    /**
     * The template for the content
     */
    readonly contentTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * The template for the header
     */
    readonly headerTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * Moves the focus to the accordion item above the current one
     */
    arrowUp(event: Event): void;
    /**
     * Moves the focus to the accordion item below the current one
     */
    arrowDown(event: Event): void;
    /**
     * Moves the focus to the first accordion item
     */
    home(): void;
    /**
     * Moves the focus to the last accordion item
     */
    end(): void;
    /**
     * Whether the accordion item is disabled
     */
    readonly disabled: i0.InputSignal<boolean>;
    /**
     * The id of the accordion item
     */
    readonly id: string;
    /**
     * Whether the accordion item is open
     */
    isOpen: WritableSignal<boolean>;
    /**
     * Whether the accordion item is focussed
     */
    protected hasFocus: WritableSignal<boolean>;
    /**
     * Updates the current open/closed state of the accordion item, regardless of the disabled state
     */
    updateAccordionItemState(isOpen: boolean): void;
    /**
     * Set the focus on the summary item
     */
    focus(): void;
    /**
     * Set the focus state of the accordion item
     *
     * @param hasFocus - Whether the item has focus
     */
    setFocus(hasFocus: boolean): void;
    /**
     * Register the item to its parent
     */
    ngOnInit(): void;
    /**
     * Listen to the default HTML events of the details object
     */
    ngAfterViewInit(): void;
    /**
     * Remove the item from its parent when destroyed
     */
    ngOnDestroy(): void;
    /**
     * Only perform an action when the item has focus
     *
     * @param  action - The provided action
     */
    protected handleWhenFocussed(action: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAccordionItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxAccordionItemComponent, "ngx-accordion-item", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["contentTemplate", "headerTemplate"], never, true, never>;
}

/**
 * A WCAG/ARIA compliant implementation of the accordion pattern.
 *
 * https://www.w3.org/WAI/ARIA/apg/patterns/accordion/
 */
declare class NgxAccordionComponent {
    /**
     * An instance of the DestroyRef
     */
    protected readonly destroyRef: DestroyRef;
    /**
     * A subject to hold a registered event
     */
    protected readonly itemRegisteredSubject: Subject<void>;
    /**
     * An observable based on the itemRegisteredSubject, sharing its replay
     */
    protected readonly itemRegistered$: Observable<void>;
    /**
     * A list of all accordion items
     */
    items: NgxAccordionItemComponent[];
    /**
     * Open the specific items in the accordion
     */
    open: InputSignal<NgxAccordionOpenBehavior>;
    /**
     * Whether all or just one item can be opened at the same time; by default this is `all`
     */
    openStateBehavior: InputSignal<NgxAccordionOpenStateBehavior>;
    constructor();
    /**
     * Register an accordion item to the container
     *
     * @param item - An accordion item
     */
    registerItem(item: NgxAccordionItemComponent): void;
    /**
     * Removes an accordion item from the container
     *
     * @param item - An accordion item
     */
    removeItem(item: NgxAccordionItemComponent): void;
    /**
     * Moves the focus to an accordion
     *
     * @param  id - The id of the current item
     * @param  direction - The direction we move in
     */
    moveFocus(id: string, direction: 'up' | 'down' | 'first' | 'last'): void;
    /**
     * Update the state of other accordion items based on the openStateBehavior
     *
     * @param id - The recently opened item
     */
    handleOpenState(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxAccordionComponent, "ngx-accordion", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "openStateBehavior": { "alias": "openStateBehavior"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare const NgxAccordion: readonly [typeof NgxAccordionComponent, typeof NgxAccordionItemComponent];

/**
 * A service that provides the currently online status of the application
 */
declare class NgxOnlineService {
    /**
     * An instance of the window service
     */
    protected readonly windowService: NgxWindowService;
    /**
     * A subject that emits whenever the application is on or offline
     */
    protected readonly onlineSubject: Subject<boolean>;
    /**
     * An observable that emits whenever the application is on or offline
     */
    readonly online$: Observable<boolean>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxOnlineService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxOnlineService>;
}

/**
 * A service that serves as a wrapper for MarkerJs2 and MarkerJs-live
 *
 * https://markerjs.com/
 */
declare class NgxImageMarkerService implements OnDestroy {
    private readonly windowService;
    /**
     * A record with all markers
     */
    private readonly markers;
    /**
     * Create an image with markers
     *
     * @param image - The image element we wish to draw markers on
     * @param rootTarget - The element we render the image in
     * @param configuration - The configuration we wish to pass to the image markers
     */
    createImageMarker(image: HTMLImageElement | HTMLElement, rootTarget: HTMLElement, configuration: NgxImageMarkerConfiguration): NgxImageMarker;
    /**
     * Creates a readonly marker view
     *
     * @param image - The image element we wish to draw markers on
     * @param rootTarget - The element we render the image in
     * @param configuration - The configuration we wish to pass to the image markers
     */
    private createReadonlyImageMarker;
    /**
     * Creates an editable marker view
     *
     * @param image - The image element we wish to draw markers on
     * @param rootTarget - The element we render the image in
     * @param configuration - The configuration we wish to pass to the image markers
     */
    private createImageMakerEdit;
    /**
     * Listen to the value changes in the editable view
     *
     * @param {MarkerArea} marker - The marker view
     */
    private createMarkerValueChanges;
    /**
     * Listen to the marker clicks in the readonly view
     *
     * @param {MarkerArea} marker - The marker view
     */
    private createMarkerClickedListener;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxImageMarkerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxImageMarkerService>;
}

/**
 * A service that can be used to track media queries and their changes.
 */
declare class NgxMediaQueryService implements OnDestroy {
    /**
     * An instance of the NgxWindowService
     */
    private readonly windowService;
    /**
     * An optional list of default mediaQueries we want to register at start time
     */
    private readonly mediaQueries;
    /**
     * A record of all the registered listeners
     */
    private listeners;
    /**
     * The id of the current query match
     */
    private readonly currentQueryMatch;
    readonly currentQueryMatch$: Observable<string>;
    constructor();
    ngOnDestroy(): void;
    /**
     * Registers one or multiple queries to listen to
     *
     * @param value - One or multiple queries to register
     */
    registerQuery(value: NgxMediaQuery | NgxMediaQuery[]): void;
    /**
     * Check if the query matches with the current screen size
     *
     * @param id - The id of the query we wish to match
     * @param predicate - Whether every or some part(s) of the query have to be matched
     */
    matchesQuery(id: string | string[], predicate?: NgxMediaQueryMatchingPredicate): Observable<boolean>;
    get queries(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMediaQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMediaQueryService>;
}

/**
 * The `NgxMobileLayoutService` allows us to configure an entire layout based on routing rather than on HTML. This allows for an easier use for mobile-first applications.
 */
declare class NgxMobileLayoutService {
    /**
     * An instance of the NgxMediaQueryService
     */
    protected readonly mediaService: NgxMediaQueryService;
    /**
     * A subject holding whether the initial layout has been set
     */
    protected readonly initialLayoutSetSubject$: BehaviorSubject<boolean>;
    /**
     * Whether the initial layout has been set
     */
    protected readonly initialLayoutSet$: Observable<boolean>;
    /**
     * An optional default layout that was provided
     */
    protected readonly defaultLayout: NgxMobileLayoutConfiguration | undefined;
    /**
     * A subject holding the current layout of the application
     */
    protected readonly layoutSubject$: BehaviorSubject<NgxMobileLayoutByQuery>;
    /**
     * Whether the flyout should be shown
     */
    protected readonly showFlyout: WritableSignal<boolean>;
    /**
     * Whether the currently opened flyout should be preserved when the route changes
     */
    protected readonly preserveFlyout: WritableSignal<boolean>;
    /**
     * Whether the aside should be shown
     */
    protected readonly showAside: WritableSignal<boolean>;
    /**
     * An array of queries
     */
    protected queries: string[];
    /**
     * The current layout of the application as an Observable
     */
    readonly layout$: Observable<NgxMobileLayout>;
    /**
     * Whether the flyout is visible
     */
    flyoutShown: Signal<boolean>;
    /**
     * The parameter context of the flyout
     */
    flyoutParams: WritableSignal<NgxMobileLayoutOutletParams>;
    /**
     * The parameter context of the aside
     */
    asideParams: WritableSignal<NgxMobileLayoutOutletParams>;
    /**
     * Whether the aside is visible
     */
    asideShown: Signal<boolean>;
    /**
     * Sets the provided layout for the
     *
     * @param layout - The layout we wish to set
     */
    setLayout(layout: NgxMobileLayoutConfiguration): Observable<boolean>;
    /**
     * Open a flyout
     *
     * @param flyout - The flyout component
     * @param params - The required parameters for the flyout
     * @param preserveFlyout - Whether the flyout needs to be preserved
     *
     */
    openFlyout(flyout: ComponentType, params: NgxMobileLayoutOutletParams, preserveFlyout?: boolean): void;
    /**
     * Close the currently open flyout
     */
    closeFlyout(): void;
    /**
     * Open an aside
     *
     * @param aside - The aside component
     * @param params - The required parameters for the aside
     */
    openAside(aside: ComponentType, params: NgxMobileLayoutOutletParams): void;
    /**
     * Close the currently open aside
     */
    closeAside(): void;
    /**
     * Provides an initial layout if one was provided
     */
    setUpInitialLayout(markAsInitial?: boolean): void;
    /**
     * Returns whether an element is defined in the layout
     *
     * @param element - The element we wish to check
     */
    hasElement(element: NgxMobileLayoutElements): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMobileLayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMobileLayoutService>;
}

/**
 * A service that can be used to parse markdown strings to HTML using the Marked library
 */
declare class NgxMarkdownService {
    /**
     * An optional set of configuration for the Marked library
     */
    private readonly configuration;
    /**
     * An instance of the Sanitizer
     */
    private readonly sanitizer;
    /**
     * An instance of the Marked library
     * https://marked.js.org/
     */
    private markedInstance;
    /**
     * Parse markdown to HTML and sanitizes the HTML string
     *
     * @param markdown - The markdown string to parse
     */
    parse(markdown: string, options?: Omit<MarkedOptions, 'async'>): Observable<string>;
    /**
     * Get the instance of the Marked library
     */
    getMarkedInstance(): Marked;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMarkdownService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMarkdownService>;
}

/**
 * A component wrapper for MarkerJs views
 *
 * https://markerjs.com/
 */
declare class NgxImageMarkerComponent implements AfterViewInit, OnChanges, OnDestroy {
    /**
     * An instance of the NgxImageMarkerService
     */
    protected readonly imageMarkerService: NgxImageMarkerService;
    /**
     * An instance of the NgxWindowService
     */
    protected readonly windowService: NgxWindowService;
    /**
     * An instance of the ElementRef
     */
    protected readonly elementRef: ElementRef;
    /**
     * The currently created marker
     */
    protected currentMarker: NgxImageMarker;
    /**
     * A subject holding the destroy state of the marker
     */
    protected readonly markerDestroyedSubject: Subject<void>;
    /**
     * The rendered image element
     */
    readonly imageElement: i0.Signal<ElementRef<any>>;
    /**
     * The url to the image we wish to render
     */
    readonly image: i0.InputSignal<string>;
    /**
     * A WCAG/WAI-ARIA compliant description of the image
     */
    readonly imageDescription: i0.InputSignal<string>;
    /**
     * The start data we wish to render
     */
    readonly startState: i0.InputSignal<markerjs2.MarkerAreaState>;
    /**
     * Whether we can edit the view, by default this is true
     */
    readonly canEdit: i0.InputSignal<boolean>;
    /**
     * An optional current zoom level
     */
    readonly currentZoomLevel: i0.InputSignal<number>;
    /**
     * An optional amount of times we can zoom in and out
     */
    readonly zoomLevels: i0.InputSignal<number[]>;
    /**
     * An optional record of types of Markerjs markers we wish to render
     */
    readonly markerTypes: i0.InputSignal<NgxImageMarkerTypes>;
    /**
     * Emits when the state has been updated
     */
    stateUpdated: OutputEmitterRef<NgxImageMarkerState>;
    /**
     * Emits when a marker is clicked when the view is in readonly mode
     */
    markerClicked: OutputEmitterRef<NgxImageMarkerItem>;
    ngAfterViewInit(): void;
    ngOnChanges(changes: any): void;
    ngOnDestroy(): void;
    /**
     * Creates a MarkerJs view based on the provided configuration
     */
    protected createMarker(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxImageMarkerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxImageMarkerComponent, "ngx-image-marker", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "imageDescription": { "alias": "imageDescription"; "required": true; "isSignal": true; }; "startState": { "alias": "startState"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "currentZoomLevel": { "alias": "currentZoomLevel"; "required": false; "isSignal": true; }; "zoomLevels": { "alias": "zoomLevels"; "required": false; "isSignal": true; }; "markerTypes": { "alias": "markerTypes"; "required": false; "isSignal": true; }; }, { "stateUpdated": "stateUpdated"; "markerClicked": "markerClicked"; }, never, never, true, never>;
}

/**
 * A component used to render a mobile-first layout
 */
declare class NgxMobileLayoutComponent implements OnInit {
    /**
     * The previous active element
     */
    protected previousActiveElement: HTMLElement;
    /**
     * The instance of the NgxMobileLayoutService
     */
    protected readonly layoutService: NgxMobileLayoutService;
    /**
     * The currently displayed layout
     */
    protected layout: Signal<NgxMobileLayout>;
    /**
     * Whether the flyout needs to be shown
     */
    protected readonly flyoutShown: Signal<boolean>;
    /**
     * Whether the aside needs to be shown
     */
    protected readonly asideShown: Signal<boolean>;
    /**
     * The params context for the aside
     */
    protected readonly asideParams: Signal<NgxMobileLayoutOutletParams>;
    /**
     * The params context for the flyout
     */
    protected readonly flyoutParams: Signal<NgxMobileLayoutOutletParams>;
    /**
     * An optional template we can pass to replace the default routerOutlet
     */
    readonly contentTemplate: Signal<TemplateRef<any>>;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMobileLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMobileLayoutComponent, "ngx-mobile-layout", never, {}, {}, ["contentTemplate"], never, true, never>;
}

type HideHeaderRowOptions = 'when-loading' | 'when-empty';
type HideHeaderRowOption = 'never' | [HideHeaderRowOptions] | [HideHeaderRowOptions, HideHeaderRowOptions];
type ShowDetailRowOption = 'always' | 'on-click' | 'on-single-item';
/**
 * A configuration we can provide to set properties of the table globally
 *
 * showDetailRow - Defines the default open behavior of detail rows. 'always' will open all rows by default, 'on-click' will only open them on click, 'on-single-item' will open the row on click and when there's only one item in the table.
 * ngxTableClass - A default class that will be set on the ngx-table component itself
 * showOpenRowState - Defines whether we always want to show the open-row state indicator for each table.
 * allowMultipleRowsOpen - Defines whether multiple rows can be open at once.
 * showOpenRowState - Defines whether we always want to show the open-row state indicator for each table.
 * showSelectedOpenRow - Defines whether we want a class to be added to the currently opened row
 * emitValueOnSingleItem - Defines whether we want to emit the rowClicked when there's only one item in the table and the showDetailRow is set to 'on-single-item'
 * hideHeaderWhen - Defines whether we want to show the header when the table is empty or loading
 * components - A set of components we can use as defaults for the loading, error and empty state of the
 * ariaLabels - Configurable fallback ARIA labels for accessibility purposes.
 */
interface NgxTableConfiguration {
    showDetailRow?: ShowDetailRowOption;
    ngxTableClass?: string;
    showOpenRowState?: boolean;
    allowMultipleRowsOpen?: boolean;
    highlightKey?: string;
    showSelectedOpenRow?: boolean;
    emitValueOnSingleItem?: boolean;
    hideHeaderWhen?: HideHeaderRowOption;
    components?: {
        loading?: Type<NgxDisplayContentComponent>;
        empty?: Type<NgxDisplayContentComponent>;
        radio?: Type<NgxTableSelectTemplateAbstractComponent>;
        checkbox?: Type<NgxTableSelectTemplateAbstractComponent>;
        openRowState?: Type<NgxTableOpenRowStateTemplateAbstractComponent>;
        sort?: Type<NgxTableSortTemplateAbstractComponent>;
    };
    ariaLabels?: NgxTableAriaLabels;
}

declare class NgxAbstractTableCellDirective {
    /**
     * The current sortDirection of the cell
     */
    sortDirection: NgxTableSortDirection | null;
    /**
     * The templates used to set in the table
     */
    footerTemplate: Signal<TemplateRef<any>>;
    headerTemplate: Signal<TemplateRef<any>>;
    cellTemplate: Signal<TemplateRef<any>>;
    /**
     * An optional class that can be set for the cell
     */
    cellClass: string;
    /**
     * The name of the column we want this cell to represent
     */
    readonly column: i0.InputSignal<string>;
    /**
     * Whether or not the cell is sortable
     */
    readonly sortable: i0.InputSignal<boolean>;
    /**
     * A tag that can be added to a column in the table, set according to the cypress best practices
     * See https://docs.cypress.io/guides/references/best-practices#Selecting-Elements
     */
    readonly cypressDataTags: i0.InputSignal<NgxTableCypressDataTags>;
    /**
     * Whether the content of a cell is editable. By default, this is set to false
     */
    readonly editable: i0.InputSignal<boolean>;
    /**
     * Emits the sortable event if a column is sortable
     */
    sort: OutputEmitterRef<NgxTableSortEvent>;
    /**
     * Handles the sorting click events
     */
    handleSort(): void;
    /**
     * Resets the sort direction back to null
     */
    resetSortDirection(): void;
    /**
     * Sets the sorting direction based on the provided direction
     *
     * @param direction - The provided direction
     */
    setSortDirection(direction: NgxTableSortDirection): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAbstractTableCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxAbstractTableCellDirective, "ngx-abstract-table-cell", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "cypressDataTags": { "alias": "cypressDataTags"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, { "sort": "sort"; }, never, never, true, never>;
}

declare class NgxTableCellDirective extends NgxAbstractTableCellDirective {
    /**
     * A template for the header of the cell
     */
    readonly headerTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * A template for the body of the cell
     */
    readonly cellTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * A template for the footer of the cell
     */
    readonly footerTemplate: i0.Signal<TemplateRef<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTableCellDirective, "ngx-table-cell", never, {}, {}, ["headerTemplate", "cellTemplate", "footerTemplate"], never, true, never>;
}

declare class NgxCurrencyTableCellComponent extends NgxAbstractTableCellDirective {
    /**
     * The [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) format of the provided amount, by default `EUR`
     */
    readonly currency: i0.InputSignal<string>;
    /**
     * A template for the header of the cell
     */
    readonly headerTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * A template for the footer of the cell
     */
    readonly footerTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * ViewChild that represents the cell template
     */
    readonly cellTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * A generic class to indicate that this is a currency cell
     */
    cellClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxCurrencyTableCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxCurrencyTableCellComponent, "ngx-table-currency-cell", never, { "currency": { "alias": "currency"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate", "footerTemplate"], never, true, never>;
}

declare class NgxDateTableCellComponent extends NgxAbstractTableCellDirective {
    /**
     * The format of the provided date, by default `dd/MM/yyyy`
     */
    readonly format: i0.InputSignal<string>;
    /**
     * The label to display when date is invalid or empty
     */
    readonly emptyLabel: i0.InputSignal<string>;
    /**
     * In case the date is nested in an object, we can provide a key to fetch it
     */
    readonly itemKey: i0.InputSignal<string>;
    /**
     * In case the date is nested in the row, we can provide a key to fetch it
     */
    readonly rowKey: i0.InputSignal<string>;
    /**
     * A template for the header of the cell
     */
    readonly headerTemplate: i0.Signal<TemplateRef<unknown>>;
    /**
     * A template for the footer of the cell
     */
    readonly footerTemplate: i0.Signal<TemplateRef<unknown>>;
    /**
     * ViewChild that represents the cell template
     */
    readonly cellTemplate: i0.Signal<TemplateRef<any>>;
    /**
     * A generic class to indicate that this is a date cell
     */
    cellClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDateTableCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxDateTableCellComponent, "ngx-table-date-cell", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate", "footerTemplate"], never, true, never>;
}

declare const Cells: (typeof NgxTableCellDirective)[];

interface TableCellTemplate {
    headerTemplate?: Signal<TemplateRef<any>>;
    cellTemplate?: Signal<TemplateRef<any>>;
    footerTemplate?: Signal<TemplateRef<any>>;
    cellClass?: string;
}
/**
 * A customizable and accessible data table component.
 *
 * ## Accessibility Guidelines
 * - **Table Cell Templates**: When defining custom templates via `cellTemplate` or `headerTemplate`, ensure all interactive elements are nested inside a native `<button>` or a valid `<a>` element rather than applying click listeners to non-semantic elements.
 * - **Color Contrast & Outlines**: Ensure overridden focus ring CSS variables (e.g. `--ngx-focus-outline`) maintain at least a **3:1** contrast ratio against the background.
 */
declare class NgxTableComponent implements AfterContentChecked, ControlValueAccessor, OnInit {
    /**
     * An instance of the ChangeDetectorRef
     */
    protected cdRef: ChangeDetectorRef;
    /**
     * An instance of the NgxTableConfiguration
     */
    readonly ngxTableConfiguration: NgxTableConfiguration;
    /**
     * An instance of the destroyRef
     */
    protected readonly destroyRef: DestroyRef;
    /**
     * Default class that will be put on the ngx-table component
     */
    readonly componentClass: string;
    /**
     * onTouch function for the control value accessor
     */
    protected onTouch: Function;
    /**
     * onChanged function for the control value accessor
     */
    protected onChanged: Function;
    /**
     * Whether or not the form was generated
     */
    protected formGenerated: boolean;
    /**
     * The current sorting event
     */
    protected currentSortingEvent: WritableSignal<NgxTableSortEvent | undefined>;
    /**
     * Keeps a record with the column and it's templates
     */
    protected tableCellTemplateRecord: WritableSignal<Record<string, TableCellTemplate>>;
    /**
     * Keeps a record of which columns are sortable
     */
    protected sortableTableCellRecord: WritableSignal<Record<string, NgxAbstractTableCellDirective>>;
    /**
     * Keeps a record of which cells have a cypress tag
     */
    protected tableCypressRecord: WritableSignal<Record<string, NgxTableCypressDataTags>>;
    /**
     * Keeps a record of which cells are editable
     */
    protected editableTableCellRecord: WritableSignal<Record<string, NgxAbstractTableCellDirective>>;
    /**
     * An object with all the open rows
     */
    protected openedRows: WritableSignal<Record<number, boolean>>;
    /**
     * A FormGroup that adds a control for each row
     */
    protected readonly rowsFormGroup: FormRecord<FormControl<boolean>>;
    /**
     * A computed signal to see if we have a form
     */
    protected readonly hasForm: Signal<boolean>;
    /**
     * A control for the select all option in the header of the table
     */
    protected readonly headerControl: FormControl<any>;
    /**
     * A control for when we use a radio button
     */
    protected readonly radioControl: FormControl<any>;
    /**
     * Whether the table functions as a treegrid
     */
    readonly isTreeGrid: Signal<boolean>;
    /**
     * Precalculates the base sort labels for each column.
     * This only re-evaluates when the sortable columns are updated.
     */
    protected readonly baseSortLabels: Signal<Record<string, string>>;
    /**
     * Reactively resolves the full ARIA label for each sort button.
     */
    readonly sortAriaLabels: Signal<Record<string, string>>;
    /**
     * A list of all defined columns
     */
    protected definedColumns: WritableSignal<string[]>;
    /**
     * Whether or not there was a footer template set somewhere in one of the cells
     */
    protected hasFooterTemplates: WritableSignal<boolean>;
    /**
     * Whether or not there was a row selected
     */
    selectedRow: WritableSignal<number | undefined>;
    /**
     * An array of table columns
     */
    protected tableColumns: WritableSignal<string[]>;
    /**
     * The currently focussed row
     */
    protected focussedRow: string;
    /**
     * The currently focussed cell
     */
    protected focussedCell: string;
    /**
     * A QueryList of all the table cell templates
     */
    protected readonly tableCellTemplates: Signal<readonly NgxAbstractTableCellDirective[]>;
    /**
     * A template to provide a detail row
     */
    protected readonly detailRowTemplate: Signal<TemplateRef<any>>;
    /**
     * A template to provide an empty view
     */
    protected readonly emptyTemplate: Signal<TemplateRef<any>>;
    /**
     * A template to provide a loading view
     */
    protected readonly loadingTemplate: Signal<TemplateRef<any>>;
    /**
     * A template to provide a checkbox template
     */
    protected checkboxTemplate: Signal<TemplateRef<any>>;
    /**
     * A template to provide a radio button template
     */
    protected radioTemplate: Signal<TemplateRef<any>>;
    /**
     * A template to provide a sort template
     */
    protected sortTemplate: Signal<TemplateRef<any>>;
    /**
     * A template to provide a open state template
     */
    protected readonly openRowStateTemplate: Signal<TemplateRef<any>>;
    /**
     * The accessible name we wish to set on the table for screen readers
     */
    readonly ariaLabel: InputSignal<string>;
    /**
     * A list of all column names we want to represent in the table
     */
    readonly columns: InputSignal<string[]>;
    /**
     * An optional list of all columns we wish to attribute to row actions, which are sorted to the end of the row by default
     */
    readonly actions: InputSignal<string[]>;
    /**
     * The data we wish to render in the table
     */
    readonly data: InputSignal<any[]>;
    /**
     * An optional property that defines whether multiple rows can be open at once.
     * By default, this is false. The default can be overwritten in the NgxTableConfiguration.
     */
    readonly allowMultipleOpenRows: InputSignal<boolean>;
    /**
     * Whether or not rows in the table are selectable
     */
    readonly selectable: InputSignal<boolean>;
    /**
     * In case the rows are selectable, we can pass a key we want to use as return value instead of the index of the row
     */
    readonly selectableKey: InputSignal<string>;
    /**
     * In case the rows are selectable, we pass whether we want a radio button or a checkbox. By default, this is a checkbox
     */
    readonly selectableType: InputSignal<"checkbox" | "radio">;
    /**
     * In case the rows are selectable, we can determine whether we want to reset the form based on new data. Setting this to false will add new controls to the FormGroup; but will not remove the earlier controls from the form.
     * This is a useful feature for when the data is being filtered or new data is added through a load more mechanic
     *
     * By default, this is true. This default cannot be overwritten in the NgxTableConfiguration.
     */
    readonly resetFormOnNewData: InputSignal<boolean>;
    /**
     *
     * The current sorting event.
     */
    currentSorting: InputSignal<NgxTableSortEvent>;
    /**
     * An optional property to define whether we want to add a class to the currently opened row.
     * By default this is false. The default can be overwritten in the NgxTableConfiguration.
     */
    readonly showSelectedOpenRow: InputSignal<boolean>;
    /**
     * An optional class to add to the rows of the table
     */
    readonly rowClass: InputSignal<string>;
    /**
     * An optional key that can be used in the data in order to highlight a row. If this property is present and true, the highlight class will be provided.
     * By default, this key is ngx-highlight. The default can be overwritten in the NgxTableConfiguration
     */
    readonly highlightKey: InputSignal<string>;
    /**
     * An optional property to define whether we want to show a visual indicator of the open and closed state of a detail row.
     * By default this is false. The default can be overwritten in the NgxTableConfiguration.
     */
    readonly showOpenRowState: InputSignal<boolean>;
    /**
     * An optional property to define the default open state of the detail row.
     * By default this is 'on-click'. The default can be overwritten in the NgxTableConfiguration.
     */
    readonly showDetailRow: InputSignal<ShowDetailRowOption>;
    /**
     * An optional property to define whether we want to emit the row when there's only one item in the table and the showDetailRow is set to `on-single-item`
     * By default this is false. The default can be overwritten in the NgxTableConfiguration.
     */
    readonly emitValueOnSingleItem: InputSignal<boolean>;
    /**
     * An optional key to open a row by default upon rendering.
     */
    defaultRowOpen: InputSignal<number>;
    /**
     * An optional property to define whether we want the header to be hidden in certain cases.
     * By default this is never. The default can be overwritten in the NgxTableConfiguration
     */
    readonly hideHeaderWhen: InputSignal<HideHeaderRowOption>;
    /**
     * An optional set of ARIA labels we wish to set on the checkboxes and radio buttons in the table selection column
     */
    readonly ariaLabels: InputSignal<NgxTableAriaLabels>;
    /**
     * Resolves the ARIA label for the selection column header.
     */
    protected readonly selectionColumnAriaLabel: Signal<string>;
    /**
     * Resolves the ARIA label for the expansion column header.
     */
    protected readonly expansionColumnAriaLabel: Signal<string>;
    /**
     * The loading state of our table
     */
    loading: InputSignal<boolean>;
    /**
     * An optional set of data we pass if the loading state is shown
     */
    loadingData: InputSignal<any>;
    /**
     * An optional set of data we pass if the empty state is shown
     */
    emptyData: InputSignal<any>;
    /**
     * Returns the data of the row that was clicked
     */
    rowClicked: OutputEmitterRef<any>;
    constructor();
    /**
     * WriteValue method for the value accessor
     *
     * @param value - The value patched to the control
     */
    writeValue(value: string[] | unknown): void;
    /**
     * Register the onChange function
     */
    registerOnChange(fn: any): void;
    /**
     * Register the onTouched function
     */
    registerOnTouched(fn: any): void;
    /**
     * Handle the disabled state of the form
     *
     * @param  isDisabled - Whether or not the form is disabled
     */
    setDisabledState?(isDisabled: boolean): void;
    /**
     * Handle a click on a row
     *
     * @param row - The data of the row that was clicked
     * @param index - The index of the row that was clicked
     */
    handleRowClicked(row: any, index: number): void;
    /**
     * Handle the expanded state of a row
     *
     * @param index - The index of the row
     * @param action - Whether the row needs to be opened or closed
     */
    handleRowState(index: number, action: 'open' | 'close'): void;
    /**
     * Assigns the templates of each cell to the correct columns
     */
    protected handleTableCellTemplates(): void;
    /**
     * Respond to a click on the sort of a column
     *
     * @param column - The column we clicked on
     */
    handleSort(column: string): void;
    selectRow(index: number): void;
    /**
     * Handle the changes in sort events
     *
     * @param event - The new sorting event
     */
    protected handleCurrentSort(event: NgxTableSortEvent): void;
    /**
     * Setup the columns array
     */
    protected handleRowColumns(): void;
    ngAfterContentChecked(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxTableComponent, "ngx-table", never, { "ariaLabel": { "alias": "ariaLabel"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "allowMultipleOpenRows": { "alias": "allowMultipleOpenRows"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selectableKey": { "alias": "selectableKey"; "required": false; "isSignal": true; }; "selectableType": { "alias": "selectableType"; "required": false; "isSignal": true; }; "resetFormOnNewData": { "alias": "resetFormOnNewData"; "required": false; "isSignal": true; }; "currentSorting": { "alias": "currentSorting"; "required": false; "isSignal": true; }; "showSelectedOpenRow": { "alias": "showSelectedOpenRow"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; "highlightKey": { "alias": "highlightKey"; "required": false; "isSignal": true; }; "showOpenRowState": { "alias": "showOpenRowState"; "required": false; "isSignal": true; }; "showDetailRow": { "alias": "showDetailRow"; "required": false; "isSignal": true; }; "emitValueOnSingleItem": { "alias": "emitValueOnSingleItem"; "required": false; "isSignal": true; }; "defaultRowOpen": { "alias": "defaultRowOpen"; "required": false; "isSignal": true; }; "hideHeaderWhen": { "alias": "hideHeaderWhen"; "required": false; "isSignal": true; }; "ariaLabels": { "alias": "ariaLabels"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingData": { "alias": "loadingData"; "required": false; "isSignal": true; }; "emptyData": { "alias": "emptyData"; "required": false; "isSignal": true; }; }, { "rowClicked": "rowClicked"; }, ["tableCellTemplates", "detailRowTemplate", "emptyTemplate", "loadingTemplate", "checkboxTemplate", "radioTemplate", "sortTemplate", "openRowStateTemplate"], never, true, never>;
}

/** All the necessary ngx-table components */
declare const NgxTable: readonly [typeof NgxTableComponent, ...typeof _ibenvandeveire_ngx_layout.NgxTableCellDirective[]];
/** All the necessary ngx-configurable layout components */
declare const NgxConfigurableLayout: readonly [typeof NgxConfigurableLayoutComponent, typeof NgxConfigurableLayoutItemComponent];

/**
 * Provides the configuration for the NgxDisplayContent directive
 *
 * @param configuration - The required configuration
 */
declare const provideNgxDisplayContentConfiguration: (configuration: NgxDisplayContentConfiguration) => Provider;

/**
 * Provides a custom implementation of the NgxDragAndDropService
 *
 * @param service - The custom implementation for the NgxDragAndDropService
 */
declare const provideNgxDragAndDropService: (service: Type<NgxAccessibleDragAndDropAbstractService>) => Provider;

/**
 * Provides the optional configuration for the NgxTable component
 *
 * @param configuration - The provided of configuration
 */
declare const provideNgxTableConfiguration: (configuration: NgxTableConfiguration) => Provider;

/**
 * Provides an optional configuration for the `NgxMobileLayoutService`
 *
 * @param configuration - The optional configuration
 */
declare const provideNgxMobileLayoutConfiguration: (configuration: NgxMobileLayoutConfiguration) => Provider;

/**
 * Provides the configuration for the NgxButton directive
 *
 * @param configuration - The required configuration
 */
declare const provideNgxButtonConfiguration: (configuration: NgxButtonConfiguration) => Provider;

/**
 * Provides an optional list of media queries for the `NgxMediaQueryService`
 *
 * @param queries - A list of queries
 */
declare const provideNgxMediaQueries: (queries: NgxMediaQuery[]) => Provider;

/**
 * Provides the configuration for the NgxLink directive
 *
 * @param configuration - The required configuration
 */
declare const provideNgxLinkConfiguration: (configuration: NgxLinkConfiguration) => Provider;

/**
 * Provides the configuration for the NgxMarkdownService
 *
 * @param configuration - The required configuration
 */
declare const provideNgxMarkdownConfiguration: (configuration: MarkedExtension[]) => Provider;

/**
 * NgxDisplayContentDirective handles whether content should be shown based on a loading, error or offline condition by using provided default components or a provided override template
 */
declare class NgxDisplayContentDirective implements AfterViewInit, OnDestroy {
    /**
     * An instance of the ElementRef
     */
    protected readonly elementRef: ElementRef<any>;
    /**
     * An instance of the TemplateRef
     */
    protected readonly templateRef: TemplateRef<any>;
    /**
     * An instance of the ChangeDetectorRef
     */
    protected readonly cdRef: ChangeDetectorRef;
    /**
     * An instance of the ViewContainerRef
     */
    protected readonly viewContainer: ViewContainerRef;
    /**
     * An instance of the OnlineService
     */
    protected readonly onlineService: NgxOnlineService;
    /**
     * The configuration used to display the content
     */
    protected readonly configuration: NgxDisplayContentConfiguration;
    /**
     * A subject to hold the destroy flow
     */
    protected readonly destroyRef: DestroyRef;
    /**
     * A subject to know when we need to update the view
     */
    protected readonly updateViewSubject: Subject<void>;
    /**
     * Holds an optional override configuration
     */
    protected overrideConfiguration: NgxDisplayContentOverrideConfiguration;
    /**
     * Holds the conditions we use to render the component
     */
    protected conditions: NgxDisplayContentConditions;
    /**
     * Renders the item or a default fallback based on the provided conditions
     */
    displayContent: InputSignal<NgxDisplayContentConditions>;
    /**
     * Override the existing configuration with custom configuration
     */
    displayContentConfiguration: InputSignal<NgxDisplayContentOverrideConfiguration>;
    /**
     * The aria-live label we wish to provide to the parent element. By default, this is 'polite'.
     *
     * https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions
     */
    readonly displayContentAriaLive: InputSignal<NgxDisplayContentAriaLive>;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Renders the provided component or template
     *
     * @param  status - The status we're handling
     * @param  component - The component we're wishing to render
     */
    protected renderTemplate(status: NgxDisplayContentStatus, component: Type<NgxDisplayContentComponent>): void;
    /**
     * Renders the initial template
     */
    protected renderInitialTemplate(): void;
    /**
     * Updates the conditions
     *
     * @param conditions - The conditions we want to merge with the current set
     */
    protected updateConditions(conditions: NgxDisplayContentConditions): void;
    /**
     * Sets the aria-live tag of the item
     * @param  value - The value we wish to set
     */
    protected setAriaLiveTag(value: 'polite' | 'assertive' | 'off'): void;
    /**
     * Sets the aria-busy tag of the item
     * @param  isLoading - The loading state of the item
     */
    protected setAriaBusyTag(isLoading: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDisplayContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDisplayContentDirective, "[displayContent]", never, { "displayContent": { "alias": "displayContent"; "required": true; "isSignal": true; }; "displayContentConfiguration": { "alias": "displayContentConfiguration"; "required": false; "isSignal": true; }; "displayContentAriaLive": { "alias": "displayContentAriaLive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A directive to handle accessible drag and drop flows. This directive is meant to be placed on the drag and drop container(s).
 */
declare class NgxAccessibleDragAndDropContainerDirective {
    /**
     * The index of the container
     */
    readonly index: i0.InputSignal<number>;
    /**
     * An optional label used in the event messages
     */
    readonly label: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAccessibleDragAndDropContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxAccessibleDragAndDropContainerDirective, "[ngxAccessibleDragAndDropContainer]", ["ngxAccessibleDragAndDropContainer"], { "index": { "alias": "ngxAccessibleDragAndDropContainerIndex"; "required": true; "isSignal": true; }; "label": { "alias": "ngxAccessibleDragAndDropContainerLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A directive to handle accessible drag and drop flows. This directive is meant to be placed on the host of the drag and drop container(s).
 */
declare class NgxAccessibleDragAndDropHostDirective implements AfterViewInit {
    private readonly dragAndDropService;
    readonly elementRef: ElementRef<HTMLElement>;
    /**
     * A list of all the drag and drop items
     */
    items: Record<string, NgxAccessibleAbstractDragAndDropItemDirective>;
    /**
     * A list of all the drag and drop containers
     */
    readonly containers: i0.Signal<readonly NgxAccessibleDragAndDropContainerDirective[]>;
    /**
     * An optional description describing how the drag and drop works.
     */
    readonly description: i0.InputSignal<string>;
    /**
     * Mark a specific drag and drop item as active
     *
     * @param  id - The id of the drag and drop item
     */
    markAsActive(id: string): void;
    /**
     * Returns the container based on the provided index
     *
     * @param index - The index of the container
     */
    getContainer(index: number): NgxAccessibleDragAndDropContainerDirective;
    ngAfterViewInit(): void;
    registerDragAndDropItem(item: NgxAccessibleAbstractDragAndDropItemDirective): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAccessibleDragAndDropHostDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxAccessibleDragAndDropHostDirective, "[ngxAccessibleDragAndDropHost]", ["ngxAccessibleDragAndDropHost"], { "description": { "alias": "ngxAccessibleDragAndDropHostDescription"; "required": false; "isSignal": true; }; }, {}, ["containers"], never, true, never>;
}

/**
 * A directive to handle accessible drag and drop flows. This directive is meant to be placed on the item(s) of the drag and drop container(s).
 */
declare class NgxAccessibleDragAndDropItemDirective extends NgxAccessibleAbstractDragAndDropItemDirective implements OnInit {
    private readonly dragAndDropService;
    private readonly dropList;
    private readonly dropContainer;
    private readonly dropHost;
    readonly elementRef: ElementRef<HTMLElement>;
    /**
     * The tab index of the item
     */
    tabIndex: WritableSignal<number>;
    /**
     * The selected state of the item
     */
    isSelected: boolean;
    /**
     * Handle the selected state when pressing enter
     */
    onEnter(): void;
    /**
     * Handle the selected state when pressing space
     */
    onSpace(): void;
    /**
     * Handle the ArrowUp Press
     */
    onArrowUp(event: Event): void;
    /**
     * Handle the ArrowDown Press
     */
    onArrowDown(event: Event): void;
    /**
     * Handle the ArrowLeft Press
     */
    onArrowLeft(event: Event): void;
    /**
     * Handle the ArrowRight Press
     */
    onArrowRight(event: Event): void;
    /**
     * The index of the draggable item
     */
    readonly itemIndex: InputSignal<number>;
    /**
     * An unique id of the draggable item
     */
    readonly itemId: InputSignal<string>;
    /**
     * An optional label for the draggable item
     */
    readonly label: InputSignal<string>;
    /**
     * Whether the draggable item  is disabled
     */
    disabled: InputSignal<boolean>;
    /**
     * Emits when the item has been moved through keyboard input
     */
    ngxAccessibleDragAndDropItemMove: OutputEmitterRef<NgxAccessibleDragAndDropMoveEvent>;
    constructor();
    /**
     *  Marks the item as focussed and selected
     */
    markAsActive(): void;
    /**
     * Deselects the current item if it's selected
     *
     */
    onBlur(): void;
    /**
     * Registers the item with the drop host
     */
    ngOnInit(): void;
    /**
     * Handles the pressing of a button in the drag and drop host
     */
    private handlePress;
    /**
     * Moves the item in the correct direction
     *
     * @param key - The pressed key
     * @param event - The keyboard event
     */
    private moveItem;
    /**
     * Moves an item based on the provided container and index, and sends a message to the live region
     *
     * @private
     * @param newIndex - The new index of the item
     * @param newContainer - The container we wish to move the item to
     * @param  type - The type of movement we perform
     */
    private handleItemMove;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAccessibleDragAndDropItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxAccessibleDragAndDropItemDirective, "[ngxAccessibleDragAndDropItem]", ["ngxAccessibleDragAndDropItem"], { "itemIndex": { "alias": "ngxAccessibleDragAndDropItemIndex"; "required": true; "isSignal": true; }; "itemId": { "alias": "ngxAccessibleDragAndDropItemId"; "required": true; "isSignal": true; }; "label": { "alias": "ngxAccessibleDragAndDropLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngxAccessibleDragAndDropDisabled"; "required": false; "isSignal": true; }; }, { "ngxAccessibleDragAndDropItemMove": "ngxAccessibleDragAndDropItemMove"; }, never, never, true, never>;
}

/**
 * All the needed directives for the accessible drag and drop implementation
 */
declare const NgxAccessibleDragAndDrop: readonly [typeof NgxAccessibleDragAndDropItemDirective, typeof NgxAccessibleDragAndDropContainerDirective, typeof NgxAccessibleDragAndDropHostDirective];

/**
 * An abstract directive used as a base to handle focussed base actions
 */
declare abstract class NgxHasFocusDirective {
    /**
     * Whether the current element is focussed
     */
    protected hasFocus: boolean;
    /**
     * Set the hasFocus flag
     */
    setFocus(): void;
    /**
     * Remove the hasFocus flag
     */
    removeFocus(): void;
    /**
     * Execute an action when the element has focussed
     *
     * @param action - The provided action
     */
    handleWhenFocussed(action: () => void): void;
    /**
   * Returns when the item has been focussed on
   */
    isFocussedOn(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxHasFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxHasFocusDirective, never, never, {}, {}, never, never, true, never>;
}

/**
 * A cell directive to handle navigation according to the WCAG treegrid pattern
 *
 * See https://www.w3.org/WAI/ARIA/apg/patterns/treegrid/
 */
declare class NgxTreeGridCellDirective extends NgxHasFocusDirective implements AfterViewInit {
    private readonly parent;
    private readonly elementRef;
    /**
     * The parent row of the cell
     */
    private row;
    /**
     * Set focus on the previous cell to the left
     */
    moveLeft(event: Event): void;
    /**
     * Set focus on the next cell to the right
     */
    moveRight(): void;
    /**
     * Set focus on the cell above
     */
    moveUp(): void;
    /**
     * Set focus on the cell below
     */
    moveDown(): void;
    /**
     * Set focus on the first cell of the grid
     */
    moveToFirstCellOfGrid(): void;
    /**
     * Set focus on the first cell of the row
     */
    moveToFirstOfRow(): void;
    /**
     * Set focus on the first cell of the same column of the grid
     */
    moveToFirstColumnOfGrid(): void;
    /**
     * Set focus on the last cell of the grid
     */
    moveToLastCellOfGrid(): void;
    /**
     * Set focus on the last cell of the row
     */
    moveToBottomEnd(): void;
    /**
     * Set focus on the last cell of the same column of the grid
     */
    moveToBottomControlEnd(): void;
    onFocusIn(): void;
    onFocusOut(): void;
    /**
     * The index of the cell in the row
     */
    readonly ngxTreeGridCell: i0.InputSignal<number>;
    /**
     * The index of the row
     */
    readonly ngxTreeGridCellRow: i0.InputSignal<number>;
    /**
     * Sets focus on the cell or on the first focusable item in the cell
     */
    focus(): void;
    /**
     * Moves focus to a provided cell in a provided row
     *
     * @private
     * @param cell - The cell we wish to put focus on
     * @param row - The row in which the cell is
     */
    private moveToCell;
    /**
     * Searches for a focusable element in the cell
     */
    private findFocusableElement;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTreeGridCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTreeGridCellDirective, "[ngxTreeGridCell]", never, { "ngxTreeGridCell": { "alias": "ngxTreeGridCell"; "required": true; "isSignal": true; }; "ngxTreeGridCellRow": { "alias": "ngxTreeGridCellRow"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A row directive to handle navigation according to the WCAG treegrid pattern
 *
 * See https://www.w3.org/WAI/ARIA/apg/patterns/treegrid/
 */
declare class NgxTreeGridRowDirective extends NgxHasFocusDirective implements OnDestroy {
    private readonly parent;
    private readonly elementRef;
    /**
     * An array of all cells in the row
     */
    private readonly cells;
    /**
     * Sets focus on to the previous row
     */
    moveUp(): void;
    /**
     * Sets focus to the next row
     */
    moveDown(): void;
    /**
     * Sets the focus on the first cell in the row or expands the row when collapsed
     */
    arrowRight(): void;
    /**
     * Expand the row when closed
     */
    arrowLeft(): void;
    /**
     * Sets focus on the first row of the grid
     */
    moveToTopPageUp(): void;
    /**
     * Sets focus on the first row of the grid
     */
    moveToTopHome(): void;
    /**
     * Sets focus on the first row of the grid
     */
    moveToTopControlHome(): void;
    /**
     * Sets focus on the last row of the grid
     */
    moveToBottomPageDown(): void;
    /**
     * Sets focus on the last row of the grid
     */
    moveToBottomEnd(): void;
    /**
     * Sets focus on the last row of the grid
     */
    moveToBottomControlEnd(): void;
    /**
     * Emits a select event to select a row
     */
    selectRowShift(): void;
    /**
     * Emits a select event to select a row
     */
    selectRowControl(): void;
    /**
     * Emits a select event to select a row below the current row and move focus to that row
     */
    selectNextRow(): void;
    /**
     * Emits a select event to select a row above the current row and move focus to that row
     */
    selectPreviousRow(): void;
    /**
     * Marks the row as expanded
     */
    /**
     * Marks the row as expanded
     */
    readonly ngxTreeGridRowExpanded: i0.InputSignal<boolean>;
    /**
     * The index of the row
     */
    readonly ngxTreeGridRow: i0.InputSignal<number>;
    /**
     * Whether the row is selectable
     */
    readonly ngxTreeGridRowSelectable: i0.InputSignal<boolean>;
    /**
     * Emits a select row event
     */
    ngxTreeGridRowSelectRow: OutputEmitterRef<void>;
    /**
     * Emits an expand row event
     */
    ngxTreeGridRowExpandRow: OutputEmitterRef<boolean>;
    constructor();
    /**
     * Registers a cell to the row
     *
     * @param  cell - The provided cell
     */
    registerCell(cell: NgxTreeGridCellDirective): void;
    /**
     * Focus on the row
     */
    focus(): void;
    /**
     * Get a cell from either the current row, or one of the other rows in the grid
     *
     * @param cell - The cell we wish to target
     * @param row - The row we wish to target
     */
    getCell(cell: NgxTreeGridCellTarget, row: NgxTreeGridRowTarget): NgxTreeGridCellDirective;
    /**
     * Emit the row event only if the row is selectable
     */
    selectRow(): void;
    /**
     * Move to the top of the grid
     */
    moveToTop(): void;
    /**
     * Move to the bottom of the grid
     *
     * @memberof NgxTreeGridRowDirective
     */
    moveToBottom(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTreeGridRowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTreeGridRowDirective, "[ngxTreeGridRow]", never, { "ngxTreeGridRowExpanded": { "alias": "ngxTreeGridRowExpanded"; "required": false; "isSignal": true; }; "ngxTreeGridRow": { "alias": "ngxTreeGridRow"; "required": true; "isSignal": true; }; "ngxTreeGridRowSelectable": { "alias": "ngxTreeGridRowSelectable"; "required": false; "isSignal": true; }; }, { "ngxTreeGridRowSelectRow": "ngxTreeGridRowSelectRow"; "ngxTreeGridRowExpandRow": "ngxTreeGridRowExpandRow"; }, never, never, true, never>;
}

/**
 * An overarching directive to handle navigation according to the WCAG treegrid pattern
 *
 * See https://www.w3.org/WAI/ARIA/apg/patterns/treegrid/
 */
declare class NgxTreeGridDirective implements OnChanges {
    /**
     * An array of all rows in the treegrid
     */
    private rows;
    role: 'table' | 'treegrid';
    /**
     * Whether the current item is a treegrid
     */
    readonly ngxTreeGrid: i0.InputSignal<boolean>;
    /**
     * Whether the treegrid has expandableRows
     */
    readonly ngxTreeGridExpandable: i0.InputSignal<boolean>;
    /**
     * Registers a row to the rows array
     *
     * @param row - The provided row
     */
    registerRow(row: NgxTreeGridRowDirective): void;
    /**
     * Removes a registered row from the grid
     *
     * @param index - The index of the provided row
     */
    removeRow(index: number): void;
    /**
     * Returns a row from the grid
     *
     * @param index - The index of the row
     */
    getRow(index: number): NgxTreeGridRowDirective;
    /**
     * Returns the first row of the grid
     */
    getFirstRow(): NgxTreeGridRowDirective;
    /**
     * Returns the last row of the grid
     */
    getLastRow(): NgxTreeGridRowDirective;
    /**
     * Moves the row focus to either the top or the bottom row of the grid
     *
     * @param direction - Whether we want to go to the top or the bottom of the grid
     */
    moveTo(direction: 'top' | 'bottom'): void;
    /**
     * Registers a a cell to a row of the grid
     *
     * @param cell - The provided cell
     */
    registerCell(index: number, cell: NgxTreeGridCellDirective): void;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTreeGridDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxTreeGridDirective, "[ngxTreeGrid]", never, { "ngxTreeGrid": { "alias": "ngxTreeGrid"; "required": true; "isSignal": true; }; "ngxTreeGridExpandable": { "alias": "ngxTreeGridExpandable"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const NgxTreeGrid: (typeof NgxTreeGridDirective | typeof NgxTreeGridCellDirective | typeof NgxTreeGridRowDirective)[];

/**
 * A directive that adds the classic button states, priority, loading and icon handling
 */
declare class NgxButtonDirective implements OnInit {
    /**
     * An instance of the viewContainer
     */
    protected readonly viewContainer: ViewContainerRef;
    /**
     * An instance of the elementRef
     */
    protected readonly elementRef: ElementRef<HTMLButtonElement>;
    /**
     * An instance of the NativeElement
     */
    protected readonly nativeElement: HTMLButtonElement;
    /**
     * An instance of the renderer
     */
    protected readonly renderer: Renderer2;
    /**
     * An optional set of configuration
     */
    protected readonly configuration: NgxButtonConfiguration;
    /**
     * The icon element in case we did not configure an icon component
     */
    protected iconElement: HTMLElement;
    /**
     * The icon component in case we did configure an icon component
     */
    protected iconComponent: ComponentRef<NgxDisplayContentComponent>;
    protected loadingComponent: ComponentRef<NgxDisplayContentComponent>;
    /**
     * The classes of the button generated by its configuration
     */
    protected buttonClasses: Signal<string>;
    /**
     * Whether the button is currently loading
     */
    loading: InputSignal<boolean>;
    /**
     * Optional loading data
     */
    loadingData: InputSignal<any>;
    /**
     * Whether the button is a regular, outline, text or fab button. By default, this is regular.
     */
    buttonType: InputSignal<NgxButtonType>;
    /**
     * Whether the button has primary, secondary, tertiary or danger priority. By default, this is primary.
     */
    priority: InputSignal<NgxButtonPriority>;
    /**
     * Whether the button has to show only the icon, the text or both. By default, this is both.
     */
    display: InputSignal<NgxButtonDisplayType>;
    /**
     * The width of the button, either full or fit. By default, this is fit.
     */
    buttonWidth: InputSignal<NgxButtonWidth>;
    /**
     * An optional icon we wish to display alongside the button text
     */
    icon: InputSignal<any>;
    /**
     * The position of the icon when provided, by default this is Left unless overwritten in the configuration
     */
    iconPosition: InputSignal<NgxButtonIconPosition>;
    constructor();
    ngOnInit(): void;
    /**
     * Adds or removes the loading component
     */
    private handleLoading;
    /**
     * Adds or removes an icon
     */
    private handleIcon;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxButtonDirective, "[ngxButton]", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingData": { "alias": "loadingData"; "required": false; "isSignal": true; }; "buttonType": { "alias": "buttonType"; "required": false; "isSignal": true; }; "priority": { "alias": "priority"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "buttonWidth": { "alias": "buttonWidth"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A directive that will render a part of the template based on whether the current screen size matches the provided query
 *
 * Based upon `*ngIf`. See https://github.com/angular/angular/blob/master/packages/common/src/directives/ng_if.ts
 */
declare class NgxMediaQueryDirective implements OnDestroy {
    protected readonly mediaQueryService: NgxMediaQueryService;
    /**
     * The provided template ref
     */
    protected readonly templateRef: TemplateRef<any>;
    /**
     * The provided ViewContainerRef
     */
    protected readonly viewContainer: ViewContainerRef;
    /**
     * The provided ChangeDetectorRef
     */
    protected readonly cdRef: ChangeDetectorRef;
    /**
     * The destroyed state of the directive
     */
    protected destroyed$: Subject<void>;
    /**
     * The needed templateRefs
     */
    protected thenTemplateRef: TemplateRef<unknown> | null;
    protected thenViewRef: EmbeddedViewRef<unknown> | null;
    protected elseTemplateRef: TemplateRef<unknown> | null;
    protected elseViewRef: EmbeddedViewRef<unknown> | null;
    /**
     * The query it should match
     */
    ngxMediaQuery: InputSignal<string | string[]>;
    /**
     * The else template in case the query isn't matched
     */
    ngxMediaQueryElse: InputSignal<TemplateRef<unknown>>;
    /**
     * Whether the query should be matched, by default this is true
     */
    ngxMediaQueryShouldMatch: InputSignal<boolean>;
    /**
     * Whether every or just some parts of the query needs to be matched
     *
     * By default this is `every`.
     */
    ngxMediaQueryMatchingPredicate: InputSignal<NgxMediaQueryMatchingPredicate>;
    constructor();
    ngOnDestroy(): void;
    /**
     * Updates the view and hides/renders the template as needed
     */
    protected updateView(): void;
    /**
     * Dispose the current subscription
     */
    protected dispose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMediaQueryDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMediaQueryDirective, "[ngxMediaQuery]", never, { "ngxMediaQuery": { "alias": "ngxMediaQuery"; "required": false; "isSignal": true; }; "ngxMediaQueryElse": { "alias": "ngxMediaQueryElse"; "required": false; "isSignal": true; }; "ngxMediaQueryShouldMatch": { "alias": "ngxMediaQueryShouldMatch"; "required": false; "isSignal": true; }; "ngxMediaQueryMatchingPredicate": { "alias": "ngxMediaQueryMatchingPredicate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A directive that adds the classic link types, priority, context, destination and icon handling
 */
declare class NgxLinkDirective implements OnInit {
    /**
     * An instance of the viewContainer
     */
    protected readonly viewContainer: ViewContainerRef;
    /**
     * An instance of the elementRef
     */
    protected readonly elementRef: ElementRef<HTMLAnchorElement>;
    /**
     * An instance of the NativeElement
     */
    protected readonly nativeElement: HTMLAnchorElement;
    /**
     * An instance of the renderer
     */
    protected readonly renderer: Renderer2;
    /**
     * An optional set of configuration
     */
    protected readonly configuration: NgxLinkConfiguration;
    /**
     * The icon element in case we did not configure an icon component
     */
    protected iconElement: HTMLElement;
    /**
     * The icon component in case we did configure an icon component
     */
    protected iconComponent: ComponentRef<NgxDisplayContentComponent>;
    /**
     * The classes we set to the link
     */
    protected readonly classes: Signal<string>;
    /**
     * The target calculated based on the destination
     */
    protected readonly target: Signal<string>;
    /**
     * The visual type of the link, by default `text`.
     *
     * The options are `text`, `button` and `icon`.
     */
    readonly linkType: InputSignal<NgxLinkType>;
    /**
     * The width of the link, either full or fit. By default, this is fit.
     */
    linkWidth: InputSignal<NgxLinkWidth>;
    /**
     * The context in which the link is used, by default undefined.
     *
     * The options are `navigation`, `breadcrumb`, `anchor`, `form` and `footer`.
     */
    readonly context: InputSignal<NgxLinkContext>;
    /**
     * The priority the link, by default `primary`.
     *
     * The options are `primary`, `secondary`, `tertiary` and `danger`.
     */
    readonly priority: InputSignal<NgxLinkPriority>;
    /**
     * The destination of the link, by default `internal`.
     *
     * The options are `internal` and `external`.
     */
    readonly destination: InputSignal<NgxLinkDestination>;
    /**
     * An optional icon we wish to show
     */
    readonly icon: InputSignal<unknown>;
    /**
     * The position of the icon when provided, by default this is `left` unless overwritten in the configuration
     *
     * The options are `left` and `right`.
     */
    readonly iconPosition: InputSignal<NgxLinkIconPosition>;
    ngOnInit(): void;
    /**
     * Adds or removes an icon
     */
    private handleIcon;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxLinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxLinkDirective, "[ngxLink]", never, { "linkType": { "alias": "linkType"; "required": false; "isSignal": true; }; "linkWidth": { "alias": "linkWidth"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "priority": { "alias": "priority"; "required": false; "isSignal": true; }; "destination": { "alias": "destination"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A guard that will set the mobile layout in the `NgxMobileLayoutService`
 */
declare const NgxMobileLayoutGuard: CanActivateFn;

/**
 * A guard that will set the default mobile layout in the `NgxMobileLayoutService`
 */
declare const NgxMobileLayoutDefaultGuard: CanDeactivateFn<ComponentType>;

declare class NgxConfigurableLayoutItemSizePipe implements PipeTransform {
    /**
     * Returns the needed styling for the ngx-configurable-layout component
     *
     * @param keys - The keys used in the grid
     * @param showInactive - Whether we want to show inactive items
     * @param itemSize - The itemSize used by the layout
     */
    transform({ keys, showInactive, }: {
        keys: NgxConfigurableLayoutItemEntity[][];
        showInactive: boolean;
    }, itemSize: NgxConfigurableLayoutItemSizeOption): Record<string, any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxConfigurableLayoutItemSizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxConfigurableLayoutItemSizePipe, "ngxConfigurableLayoutItemSize", true>;
}

/**
 * This pipe returns a value based on a provided path
 *
 * @export
 * @class NgxTableGetPipe
 * @implements {PipeTransform}
 */
declare class NgxTableGetPipe implements PipeTransform {
    transform(value: unknown, path: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableGetPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxTableGetPipe, "getProp", true>;
}

/**
 * A pipe that parses a markdown string to HTML using the Marked library
 * https://marked.js.org/
 */
declare class NgxMarkdownPipe implements PipeTransform, OnDestroy {
    /**
     * An instance of the NgxMarkdownService
     */
    protected readonly markdownService: NgxMarkdownService;
    /**
     * An instance of the ChangeDetectorRef
     */
    protected readonly cdRef: ChangeDetectorRef;
    /**
     * An instance of the ElementRef
     */
    protected readonly elementRef: ElementRef;
    /**
     * An instance of the Renderer2
     */
    protected readonly renderer: Renderer2;
    /**
     * Subject to hold the destroyed state of the current observable
     */
    protected destroyed$: Subject<void>;
    /**
     * The latest value of the Observable, the parsed markdown
     */
    protected parsed: string;
    /**
     * The previous value of the markdown string
     */
    protected previousValue: string;
    /**
     * Instance of the change detector ref, implemented like this according to the async pipe implementation
     * https://github.com/angular/angular/blob/main/packages/common/src/pipes/async_pipe.ts
     */
    protected changeDetectorRef: ChangeDetectorRef | null;
    constructor();
    /**
     * Parse a markdown string to HTML
     *
     * @param value - The markdown string to parse
     */
    transform(value: string, options?: Omit<MarkedOptions, 'async'>): string;
    /**
     * Handles the changeDetection, latest value and dispose of the matchesQuery observable
     *
     * @param observable - The parsed markdown observable
     */
    protected subscribe(observable: Observable<string>): void;
    ngOnDestroy(): void;
    /**
     * Dispose of the matchesQuery observable when existing
     */
    protected dispose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMarkdownPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMarkdownPipe, "ngxMarkdown", true>;
}

/**
 * This pipe returns whether we want to show the header
 *
 * @export
 * @class NgxTableShowHeaderPipe
 * @implements {PipeTransform}
 */
declare class NgxTableShowHeaderPipe implements PipeTransform {
    transform(value: NgxTableShowHeaderRequirements, hideHeaderRowWhen: HideHeaderRowOption): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableShowHeaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxTableShowHeaderPipe, "ngxTableShowHeader", true>;
}

declare class NgxTableHasObserversPipe implements PipeTransform {
    /**
     * Returns true in case an observer was set to an EventEmitter
     *
     * @param output - The provided EventEmitter
     */
    transform(output: OutputEmitterRef<unknown>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableHasObserversPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxTableHasObserversPipe, "ngxTableHasObservers", true>;
}

declare class NgxTableSortIconPipe implements PipeTransform {
    /**
     * Returns a icon based on the provided sort direction
     *
     * @param direction - The provided sort direction
     */
    transform(direction: null | NgxTableSortDirection): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableSortIconPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxTableSortIconPipe, "ngxTableSortIcon", true>;
}

declare class NgxAriaSortPipe implements PipeTransform {
    transform(value: {
        currentSorting: NgxTableSortEvent;
        cell: NgxAbstractTableCellDirective;
    }): 'none' | 'ascending' | 'descending';
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxAriaSortPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxAriaSortPipe, "ngxAriaSort", true>;
}

/**
 * A pipe that returns whether a (list of) query(s) have been matched
 */
declare class NgxMatchesQueryPipe implements PipeTransform, OnDestroy {
    /**
     * An instance of the NgxMediaQueryService
     */
    protected readonly mediaService: NgxMediaQueryService;
    /**
     * An instance of the ChangeDetectorRef
     */
    protected readonly cdRef: ChangeDetectorRef;
    /**
     * Subject to hold the destroyed state of the current observable
     */
    protected destroyed$: Subject<void>;
    /**
     * The latest value of the Observable, whether or not the query is matched
     */
    protected matchesQuery: boolean;
    /**
     * Instance of the change detector ref, implemented like this according to the async pipe implementation
     * https://github.com/angular/angular/blob/main/packages/common/src/pipes/async_pipe.ts
     */
    protected changeDetectorRef: ChangeDetectorRef | null;
    constructor();
    ngOnDestroy(): void;
    /**
     * Returns whether or not a query is matched
     *
     * @param query - The provided query
     * @param predicate - Whether every or some part(s) of the query have to be matched
     */
    transform(query: string | string[], predicate?: NgxMediaQueryMatchingPredicate): boolean;
    /**
     * Handles the changeDetection, latest value and dispose of the matchesQuery observable
     *
     * @param observable - The matchesQuery observable
     */
    protected subscribe(observable: Observable<boolean>): void;
    /**
     * Dispose of the matchesQuery observable when existing
     */
    protected dispose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatchesQueryPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatchesQueryPipe, "ngxMatchesQuery", true>;
}

declare class NgxTableAriaLabelPipe implements PipeTransform {
    /**
     * The global configuration we wish to use for the table
     */
    private readonly globalConfig;
    /**
     * Resolves the ARIA label we wish to set on the selection and expansion controls
     *
     * @param index - The index of the row we wish to target, undefined for the header controls
     * @param type - The action type we wish to perform
     * @param config - The custom ARIA labels configuration we wish to use
     */
    transform(index: number | undefined, type: 'select' | 'expand' | 'collapse', config?: NgxTableAriaLabels): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableAriaLabelPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxTableAriaLabelPipe, "ngxTableAriaLabel", true>;
}

declare const Pipes: (typeof NgxTableGetPipe | typeof NgxMarkdownPipe | typeof NgxTableShowHeaderPipe)[];

export { Cells, NgxAbstractTableCellDirective, NgxAccessibleAbstractDragAndDropItemDirective, NgxAccessibleDragAndDrop, NgxAccessibleDragAndDropAbstractService, NgxAccordion, NgxAccordionComponent, NgxAccordionItemComponent, NgxAriaSortPipe, NgxButtonDirective, NgxConfigurableLayout, NgxConfigurableLayoutComponent, NgxConfigurableLayoutItemComponent, NgxConfigurableLayoutItemSizePipe, NgxCurrencyTableCellComponent, NgxDateTableCellComponent, NgxDisplayContentComponent, NgxDisplayContentDirective, NgxHasFocusDirective, NgxHasFocusDragAndDropAbstractDirective, NgxImageMarkerComponent, NgxImageMarkerService, NgxLinkDirective, NgxMarkdownPipe, NgxMarkdownService, NgxMatchesQueryPipe, NgxMediaQueryDirective, NgxMediaQueryService, NgxMobileLayoutComponent, NgxMobileLayoutDefaultGuard, NgxMobileLayoutGuard, NgxMobileLayoutService, NgxOnlineService, NgxTable, NgxTableAriaLabelPipe, NgxTableCellDirective, NgxTableComponent, NgxTableGetPipe, NgxTableHasObserversPipe, NgxTableOpenRowStateTemplateAbstractComponent, NgxTableSelectTemplateAbstractComponent, NgxTableShowHeaderPipe, NgxTableSortDirection, NgxTableSortIconPipe, NgxTableSortTemplateAbstractComponent, NgxTreeGrid, Pipes, provideNgxButtonConfiguration, provideNgxDisplayContentConfiguration, provideNgxDragAndDropService, provideNgxLinkConfiguration, provideNgxMarkdownConfiguration, provideNgxMediaQueries, provideNgxMobileLayoutConfiguration, provideNgxTableConfiguration };
export type { ComponentType, NgxAccessibleDragAndDropMessage, NgxAccessibleDragAndDropMessageRecord, NgxAccessibleDragAndDropMoveEvent, NgxAccessibleDragAndDropMoveType, NgxAccordionOpenBehavior, NgxAccordionOpenStateBehavior, NgxButtonConfiguration, NgxButtonDisplayType, NgxButtonIconPosition, NgxButtonPriority, NgxButtonType, NgxButtonWidth, NgxConfigurableLayoutGrid, NgxConfigurableLayoutItemDropEvent, NgxConfigurableLayoutItemEntity, NgxConfigurableLayoutItemSizeOption, NgxConfigurableLayoutType, NgxDisplayContentAriaLive, NgxDisplayContentComponentConfiguration, NgxDisplayContentConditions, NgxDisplayContentConfiguration, NgxDisplayContentOverrideConfiguration, NgxDisplayContentStatus, NgxImageMarker, NgxImageMarkerConfiguration, NgxImageMarkerEdit, NgxImageMarkerItem, NgxImageMarkerState, NgxImageMarkerTypes, NgxImageMarkerView, NgxLinkConfiguration, NgxLinkContext, NgxLinkDestination, NgxLinkIconPosition, NgxLinkPriority, NgxLinkType, NgxLinkWidth, NgxMediaQuery, NgxMediaQueryMatchingPredicate, NgxMobileLayout, NgxMobileLayoutBase, NgxMobileLayoutByQuery, NgxMobileLayoutConfiguration, NgxMobileLayoutElements, NgxMobileLayoutItem, NgxMobileLayoutOutletParams, NgxTableAriaLabels, NgxTableCypressDataTags, NgxTableShowHeaderRequirements, NgxTableSortEvent, NgxTreeGridCellTarget, NgxTreeGridRowTarget };