import * as i0 from '@angular/core';
import { InjectionToken, OnChanges, OnDestroy, OnInit, EventEmitter, AfterViewInit, Optional, ChangeDetectorRef } from '@angular/core';
import { Subject, Observable, Subscription, BehaviorSubject } from 'rxjs';
import * as i1 from '@angular/cdk/table';
import { CdkCellDef, CdkTable, CdkHeaderCellDef, CdkFooterCellDef, CdkColumnDef, CdkHeaderCell, CdkFooterCell, CdkCell, DataSource, CdkHeaderRowDef, CdkFooterRowDef, CdkRowDef, CdkHeaderRow, CdkFooterRow, CdkRow, CdkNoDataRow, CdkTextColumn } from '@angular/cdk/table';

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
type SortDirection = 'asc' | 'desc' | '';

/**
 * @license
 * Original work Copyright Google LLC All Rights Reserved.
 * Modified work Copyright DatePoll-Systems
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/** Position of the arrow that displays when sorted. */
type SortHeaderArrowPosition = 'before' | 'after';
/** Interface for a directive that holds sorting state consumed by `NgbSortHeader`. */
interface NgbSortable {
    /** The id of the column being sorted. */
    id: string;
    /** Starting sort direction. */
    start: SortDirection;
    /** Whether to disable clearing the sorting state. */
    disableClear: boolean;
}
/** The current sort state. */
interface Sort {
    /** The id of the column being sorted. */
    active: string;
    /** The sort direction. */
    direction: SortDirection;
}
/** Default options for `ngb-sort`.  */
interface NgbSortDefaultOptions {
    /** Whether to disable clearing the sorting state. */
    disableClear?: boolean;
    /** Position of the arrow that displays when sorted. */
    arrowPosition?: SortHeaderArrowPosition;
}
/** Injection token to be used to override the default options for `ngb-sort`. */
declare const NGB_SORT_DEFAULT_OPTIONS: InjectionToken<NgbSortDefaultOptions>;
/** Container for NgbSortable to manage the sort state and provide default sort parameters. */
declare class NgbSort implements OnChanges, OnDestroy, OnInit {
    private _initializedStream;
    /** Collection of all registered sortables that this directive manages. */
    sortables: Map<string, NgbSortable>;
    /** Used to notify any child components listening to state changes. */
    readonly _stateChanges: Subject<void>;
    /** The id of the most recently sorted NgbSortable. */
    active: string;
    /**
     * The direction to set when an NgbSortable is initially sorted.
     * May be overridden by the NgbSortable's sort start.
     */
    start: SortDirection;
    /** The sort direction of the currently active NgbSortable. */
    get direction(): SortDirection;
    set direction(direction: SortDirection);
    private _direction;
    /**
     * Whether to disable the user from clearing the sort by finishing the sort direction cycle.
     * May be overridden by the NgbSortable's disable clear input.
     */
    disableClear: boolean;
    /** Whether the sortable is disabled. */
    disabled: boolean;
    /** Event emitted when the user changes either the active sort or sort direction. */
    readonly sortChange: EventEmitter<Sort>;
    /** Emits when the paginator is initialized. */
    initialized: Observable<void>;
    private _defaultOptions;
    /**
     * Register function to be used by the contained NgbSortables. Adds the NgbSortable to the
     * collection of NgbSortables.
     */
    register(sortable: NgbSortable): void;
    /**
     * Unregister function to be used by the contained NgbSortable. Removes the NgbSortable from the
     * collection of contained NgbSortable.
     */
    deregister(sortable: NgbSortable): void;
    /** Sets the active sort id and determines the new sort direction. */
    sort(sortable: NgbSortable): void;
    /** Returns the next sort direction of the active sortable, checking for potential overrides. */
    getNextSortDirection(sortable: NgbSortable): SortDirection;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSort, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSort, "[ngb-sort]", ["ngbSort"], { "active": { "alias": "ngbSortActive"; "required": false; }; "start": { "alias": "ngbSortStart"; "required": false; }; "direction": { "alias": "ngbSortDirection"; "required": false; }; "disableClear": { "alias": "ngbSortDisableClear"; "required": false; }; "disabled": { "alias": "ngbSortDisabled"; "required": false; }; }, { "sortChange": "ngbSortChange"; }, never, never, true, never>;
    static ngAcceptInputType_disableClear: unknown;
    static ngAcceptInputType_disabled: unknown;
}

/** Column definition associated with a `NgbSortHeader`. */
interface NgbSortHeaderColumnDef {
    name: string;
}
/**
 * Applies sorting behavior (click to change sort) and styles to an element, including an
 * arrow to display the current sort direction.
 *
 * Must be provided with an id and contained within a parent NgbSort directive.
 *
 * If used on header cells in a CdkTable, it will automatically default its id from its containing
 * column definition.
 */
declare class NgbSortHeader implements NgbSortable, OnDestroy, OnInit, AfterViewInit {
    _sort: NgbSort;
    _columnDef: NgbSortHeaderColumnDef | null;
    private _changeDetectorRef;
    private _focusMonitor;
    private _elementRef;
    private _ariaDescriber;
    private _renderChanges;
    protected _animationModule: "NoopAnimations" | "BrowserAnimations" | null;
    /**
     * Indicates which state was just cleared from the sort header.
     * Will be reset on the next interaction. Used for coordinating animations.
     */
    protected _recentlyCleared: i0.WritableSignal<SortDirection | null>;
    /**
     * The element with role="button" inside this component's view. We need this
     * in order to apply a description with AriaDescriber.
     */
    private _sortButton;
    /**
     * ID of this sort header. If used within the context of a CdkColumnDef, this will default to
     * the column's name.
     */
    id: string;
    /** Sets the position of the arrow that displays when sorted. */
    arrowPosition: SortHeaderArrowPosition;
    /** Overrides the sort start value of the containing NgbSort for this NgbSortable. */
    start: SortDirection;
    /** whether the sort header is disabled. */
    disabled: boolean;
    /**
     * Description applied to NgbSortHeader's button element with aria-describedby. This text should
     * describe the action that will occur when the user clicks the sort header.
     */
    get sortActionDescription(): string;
    set sortActionDescription(value: string);
    private _sortActionDescription;
    /** Overrides the disable clear value of the containing NgbSort for this NgbSortable. */
    disableClear: boolean;
    constructor(...args: unknown[]);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /** Triggers the sort on this sort header and removes the indicator hint. */
    _toggleOnInteraction(): void;
    _handleKeydown(event: KeyboardEvent): void;
    /** Whether this NgbSortHeader is currently sorted in either ascending or descending order. */
    _isSorted(): boolean;
    _isDisabled(): boolean;
    /**
     * Gets the aria-sort attribute that should be applied to this sort header. If this header
     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
     * says that the aria-sort property should only be present on one header at a time, so removing
     * ensures this is true.
     */
    _getAriaSortAttribute(): "none" | "ascending" | "descending";
    /** Whether the arrow inside the sort header should be rendered. */
    _renderArrow(): boolean;
    private _updateSortActionDescription;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSortHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSortHeader, "[ngb-sort-header]", ["ngbSortHeader"], { "id": { "alias": "ngb-sort-header"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "start": { "alias": "start"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "sortActionDescription": { "alias": "sortActionDescription"; "required": false; }; "disableClear": { "alias": "disableClear"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_disableClear: unknown;
}

declare class DfxSortModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DfxSortModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DfxSortModule, never, [typeof NgbSort, typeof NgbSortHeader], [typeof NgbSort, typeof NgbSortHeader]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DfxSortModule>;
}

/**
 * To modify the labels and text displayed, create a new instance of NgbPaginatorIntl and
 * include it in a custom provider
 */
declare class NgbPaginatorIntl {
    /**
     * Stream to emit from when labels are changed. Use this to notify components when the labels have
     * changed after initialization.
     */
    readonly changes: Subject<void>;
    /** A label for the page size selector. */
    itemsPerPageLabel: string;
    /** A label for the button that increments the current page. */
    nextPageLabel: string;
    /** A label for the button that decrements the current page. */
    previousPageLabel: string;
    /** A label for the button that moves to the first page. */
    firstPageLabel: string;
    /** A label for the button that moves to the last page. */
    lastPageLabel: string;
    /** A label for the range of items within the current page and the length of the whole list. */
    getRangeLabel: (page: number, pageSize: number, length: number) => string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPaginatorIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgbPaginatorIntl>;
}
/** @docs-private */
declare function NGB_PAGINATOR_INTL_PROVIDER_FACTORY(parentIntl: NgbPaginatorIntl): NgbPaginatorIntl;
/** @docs-private */
declare const NGB_PAGINATOR_INTL_PROVIDER: {
    provide: typeof NgbPaginatorIntl;
    deps: Optional[][];
    useFactory: typeof NGB_PAGINATOR_INTL_PROVIDER_FACTORY;
};

/**
 * Change event object that is emitted when the user selects a
 * different page size or navigates to another page.
 */
interface PageEvent {
    /** The current page index. */
    pageIndex: number;
    /** Index of the page that was selected previously. */
    previousPageIndex: number;
    /** The current page size. */
    pageSize: number;
    /** The current total number of items being paged. */
    length: number;
}
/** Object that can be used to configure the default options for the paginator module. */
interface NgbPaginatorDefaultOptions {
    /** Number of items to display on a page. By default set to 50. */
    pageSize?: number;
    /** The set of provided page size options to display to the user. */
    pageSizeOptions?: number[];
    /** Whether to hide the page size selection UI from the user. */
    hidePageSize?: boolean;
    /** Whether to show the first/last buttons UI to the user. */
    showFirstLastButtons?: boolean;
}
/** Injection token that can be used to provide the default options for the paginator module. */
declare const NGB_PAGINATOR_DEFAULT_OPTIONS: InjectionToken<NgbPaginatorDefaultOptions>;
declare class NgbPaginator implements OnInit, OnDestroy {
    _intl: NgbPaginatorIntl;
    private _changeDetectorRef;
    /** ID for the DOM node containing the paginator's items per page label. */
    readonly _pageSizeLabelId: string;
    private _intlChanges;
    private _isInitialized;
    private _initializedStream;
    /** The zero-based page index of the displayed list of items. Defaulted to 0. */
    get pageIndex(): number;
    set pageIndex(value: number);
    private _pageIndex;
    /** The length of the total number of items that are being paginated. Defaulted to 0. */
    get length(): number;
    set length(value: number);
    private _length;
    /** Number of items to display on a page. By default set to 50. */
    get pageSize(): number;
    set pageSize(value: number);
    private _pageSize;
    /** The set of provided page size options to display to the user. */
    get pageSizeOptions(): number[];
    set pageSizeOptions(value: number[] | readonly number[]);
    private _pageSizeOptions;
    /** Whether to hide the page size selection UI from the user. */
    hidePageSize: boolean;
    /** Whether to show the first/last buttons UI to the user. */
    showFirstLastButtons: boolean;
    /** Whether the paginator is disabled. */
    disabled: boolean;
    /**
     * The paginator display size.
     *
     * Bootstrap currently supports small and large sizes.
     */
    size?: 'sm' | 'lg' | null;
    /** Event emitted when the paginator changes the page size or page index. */
    readonly page: EventEmitter<PageEvent>;
    /** Displayed set of page size options. Will be sorted and include current page size. */
    _displayedPageSizeOptions: number[];
    /** Emits when the paginator is initialized. */
    initialized: Observable<void>;
    constructor(_intl: NgbPaginatorIntl, _changeDetectorRef: ChangeDetectorRef, defaults?: NgbPaginatorDefaultOptions);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /** Advances to the next page if it exists. */
    nextPage(): void;
    /** Move back to the previous page if it exists. */
    previousPage(): void;
    /** Move to the first page if not already there. */
    firstPage(): void;
    /** Move to the last page if not already there. */
    lastPage(): void;
    /** Whether there is a previous page. */
    hasPreviousPage(): boolean;
    /** Whether there is a next page. */
    hasNextPage(): boolean;
    /** Calculate the number of pages */
    getNumberOfPages(): number;
    /**
     * Changes the page size so that the first item displayed on the page will still be
     * displayed using the new page size.
     *
     * For example, if the page size is 10 and on the second page (items indexed 10-19) then
     * switching so that the page size is 5 will set the third page as the current page so
     * that the 10th item will still be displayed.
     */
    _changePageSize(pageSize: number): void;
    /** Checks whether the buttons for going forwards should be disabled. */
    _nextButtonsDisabled(): boolean;
    /** Checks whether the buttons for going backwards should be disabled. */
    _previousButtonsDisabled(): boolean;
    /**
     * Updates the list of page size options to display to the user. Includes making sure that
     * the page size is an option and that the list is sorted.
     */
    private _updateDisplayedPageSizeOptions;
    /** Emits an event notifying that a change of the paginator's properties has been triggered. */
    private _emitPageEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPaginator, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbPaginator, "ngb-paginator", ["ngbPaginator"], { "pageIndex": { "alias": "pageIndex"; "required": false; }; "length": { "alias": "length"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "hidePageSize": { "alias": "hidePageSize"; "required": false; }; "showFirstLastButtons": { "alias": "showFirstLastButtons"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "page": "page"; }, never, never, true, never>;
    static ngAcceptInputType_pageIndex: unknown;
    static ngAcceptInputType_length: unknown;
    static ngAcceptInputType_pageSize: unknown;
    static ngAcceptInputType_hidePageSize: unknown;
    static ngAcceptInputType_showFirstLastButtons: unknown;
    static ngAcceptInputType_disabled: unknown;
}

declare class DfxPaginationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DfxPaginationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DfxPaginationModule, never, [typeof NgbPaginator], [typeof NgbPaginator]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DfxPaginationModule>;
}

/**
 * @license
 * Original work Copyright Google LLC All Rights Reserved.
 * Modified work Copyright DatePoll-Systems
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * Cell definition for the ngb-table.
 * Captures the template of a column's data row cell as well as cell-specific properties.
 */
declare class NgbCellDef<T> extends CdkCellDef {
    ngbCellDefTable?: CdkTable<T>;
    static ngTemplateContextGuard<T>(dir: NgbCellDef<T>, ctx: unknown): ctx is {
        $implicit: T;
        index: number;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCellDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCellDef<any>, "[ngbCellDef]", never, { "ngbCellDefTable": { "alias": "ngbCellDefTable"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Header cell definition for the ngb-table.
 * Captures the template of a column's header cell and as well as cell-specific properties.
 */
declare class NgbHeaderCellDef extends CdkHeaderCellDef {
    whiteSpace: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeaderCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbHeaderCellDef, "[ngbHeaderCellDef]", never, { "whiteSpace": { "alias": "whiteSpace"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Footer cell definition for the ngb-table.
 * Captures the template of a column's footer cell and as well as cell-specific properties.
 */
declare class NgbFooterCellDef extends CdkFooterCellDef {
    whiteSpace: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbFooterCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbFooterCellDef, "[ngbFooterCellDef]", never, { "whiteSpace": { "alias": "whiteSpace"; "required": false; }; }, {}, never, never, true, never>;
}
declare const ngbSortHeaderColumnDef: InjectionToken<unknown>;
/**
 * Column definition for the ngb-table.
 * Defines a set of cells available for a table column.
 */
declare class NgbColumnDef extends CdkColumnDef {
    /** Unique name for this column. */
    get name(): string;
    set name(name: string);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbColumnDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColumnDef, "[ngbColumnDef]", never, { "name": { "alias": "ngbColumnDef"; "required": false; }; }, {}, never, never, true, never>;
}
/** Header cell template container that adds the right classes and role. */
declare class NgbHeaderCell extends CdkHeaderCell {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeaderCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbHeaderCell, "ngb-header-cell, th[ngb-header-cell]", never, {}, {}, never, never, true, never>;
}
/** Footer cell template container that adds the right classes and role. */
declare class NgbFooterCell extends CdkFooterCell {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbFooterCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbFooterCell, "ngb-footer-cell, td[ngb-footer-cell]", never, {}, {}, never, never, true, never>;
}
/** Cell template container that adds the right classes and role. */
declare class NgbCell extends CdkCell {
    whiteSpace: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCell, "ngb-cell, td[ngb-cell]", never, { "whiteSpace": { "alias": "whiteSpace"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Data source that accepts a client-side data array and includes native support of filtering,
 * sorting (using NgbSort), and pagination (using NgbPaginator).
 *
 * Allows for sort customization by overriding sortingDataAccessor, which defines how data
 * properties are accessed. Also allows for filter customization by overriding filterPredicate,
 * which defines how row data is converted to a string for filter matching.
 *
 * **Note:** This class is meant to be a simple data source to help you get started. As such
 * it isn't equipped to handle some more advanced cases like robust i18n support or server-side
 * interactions. If your app needs to support more advanced use cases, consider implementing your
 * own `DataSource`.
 */
declare class NgbTableDataSource<T, P extends NgbPaginator = NgbPaginator> extends DataSource<T> {
    /** Stream that emits when a new data array is set on the data source. */
    private readonly _data;
    /** Stream emitting render data to the table (depends on ordered data changes). */
    private readonly _renderData;
    /** Stream that emits when a new filter string is set on the data source. */
    private readonly _filter;
    /** Used to react to internal changes of the paginator that are made by the data source itself. */
    private readonly _internalPageChanges;
    /**
     * Subscription to the changes that should trigger an update to the table's rendered rows, such
     * as filtering, sorting, pagination, or base data changes.
     */
    _renderChangesSubscription: Subscription | null;
    /**
     * The filtered set of data that has been matched by the filter string, or all the data if there
     * is no filter. Useful for knowing the set of data the table represents.
     * For example, a 'selectAll()' function would likely want to select the set of filtered data
     * shown to the user rather than all the data.
     */
    filteredData: T[];
    /** Array of data that should be rendered by the table, where each object represents one row. */
    get data(): T[];
    set data(data: T[]);
    /**
     * Filter term that should be used to filter out objects from the data array. To override how
     * data objects match to this filter string, provide a custom function for filterPredicate.
     */
    get filter(): string;
    set filter(filter: string);
    /**
     * Instance of the NgbSort directive used by the table to control its sorting. Sort changes
     * emitted by the NgbSort will trigger an update to the table's rendered data.
     */
    get sort(): NgbSort | null | undefined;
    set sort(sort: NgbSort | null | undefined);
    private _sort?;
    /**
     * Instance of the paginator component used by the table to control what page of the data is
     * displayed. Page changes emitted by the paginator will trigger an update to the
     * table's rendered data.
     *
     * Note that the data source uses the paginator's properties to calculate which page of data
     * should be displayed. If the paginator receives its properties as template inputs,
     * e.g. `[pageLength]=100` or `[pageIndex]=1`, then be sure that the paginator's view has been
     * initialized before assigning it to this data source.
     */
    get paginator(): P | null | undefined;
    set paginator(paginator: P | null | undefined);
    private _paginator?;
    /**
     * Data accessor function that is used for accessing data properties for sorting through
     * the default sortData function.
     * This default function assumes that the sort header IDs (which defaults to the column name)
     * matches the data's properties (e.g. column Xyz represents data['Xyz']).
     * May be set to a custom function for different behavior.
     * @param data Data object that is being accessed.
     * @param sortHeaderId The name of the column that represents the data.
     */
    sortingDataAccessor: (data: T, sortHeaderId: string) => string | number;
    /**
     * Gets a sorted copy of the data array based on the state of the NgbSort. Called
     * after changes are made to the filtered data or when sort changes are emitted from NgbSort.
     * By default, the function retrieves the active sort and its direction and compares data
     * by retrieving data using the sortingDataAccessor. May be overridden for a custom implementation
     * of data ordering.
     * @param data The array of data that should be sorted.
     * @param sort The connected NgbSort that holds the current sort state.
     */
    sortData: (data: T[], sort: NgbSort) => T[];
    /**
     * Checks if a data object matches the data source's filter string. By default, each data object
     * is converted to a string of its properties and returns true if the filter has
     * at least one occurrence in that string. By default, the filter string has its whitespace
     * trimmed and the match is case-insensitive. May be overridden for a custom implementation of
     * filter matching.
     * @param data Data object used to check against the filter.
     * @param filter Filter string that has been set on the data source.
     * @returns Whether the filter matches against the data
     */
    filterPredicate: (data: T, filter: string) => boolean;
    constructor(initialData?: T[]);
    /**
     * Subscribe to changes that should trigger an update to the table's rendered rows. When the
     * changes occur, process the current state of the filter, sort, and pagination along with
     * the provided base data and send it to the table for rendering.
     */
    _updateChangeSubscription(): void;
    /**
     * Returns a filtered data array where each filter object contains the filter string within
     * the result of the filterPredicate function. If no filter is set, returns the data array
     * as provided.
     */
    _filterData(data: T[]): T[];
    /**
     * Returns a sorted copy of the data if NgbSort has a sort applied, otherwise just returns the
     * data array as provided. Uses the default data accessor for data lookup, unless a
     * sortDataAccessor function is defined.
     */
    _orderData(data: T[]): T[];
    /**
     * Returns a paged slice of the provided data array according to the provided paginator's page
     * index and length. If there is no paginator provided, returns the data array as provided.
     */
    _pageData(data: T[]): T[];
    /**
     * Updates the paginator to reflect the length of the filtered data, and makes sure that the page
     * index does not exceed the paginator's last page. Values are changed in a resolved promise to
     * guard against making property changes within a round of change detection.
     */
    _updatePaginator(filteredDataLength: number): void;
    /**
     * Used by the NgbTable. Called when it connects to the data source.
     * @docs-private
     */
    connect(): BehaviorSubject<T[]>;
    /**
     * Used by the NgbTable. Called when it disconnects from the data source.
     * @docs-private
     */
    disconnect(): void;
}

/**
 * @license
 * Original work Copyright Google LLC All Rights Reserved.
 * Modified work Copyright DatePoll-Systems
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * Header row definition for the ngb-table.
 * Captures the header row's template and other header properties such as the columns to display.
 */
declare class NgbHeaderRowDef extends CdkHeaderRowDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeaderRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbHeaderRowDef, "[ngbHeaderRowDef]", never, { "columns": { "alias": "ngbHeaderRowDef"; "required": false; }; "sticky": { "alias": "ngbHeaderRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_sticky: unknown;
}
/**
 * Footer row definition for the ngb-table.
 * Captures the footer row's template and other footer properties such as the columns to display.
 */
declare class NgbFooterRowDef extends CdkFooterRowDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbFooterRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbFooterRowDef, "[ngbFooterRowDef]", never, { "columns": { "alias": "ngbFooterRowDef"; "required": false; }; "sticky": { "alias": "ngbFooterRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_sticky: unknown;
}
/**
 * Data row definition for the ngb-table.
 * Captures the data row's template and other properties such as the columns to display and
 * a when predicate that describes when this row should be used.
 */
declare class NgbRowDef<T> extends CdkRowDef<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbRowDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbRowDef<any>, "[ngbRowDef]", never, { "columns": { "alias": "ngbRowDefColumns"; "required": false; }; "when": { "alias": "ngbRowDefWhen"; "required": false; }; }, {}, never, never, true, never>;
}
/** Header template container that contains the cell outlet. Adds the right class and role. */
declare class NgbHeaderRow extends CdkHeaderRow {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeaderRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbHeaderRow, "ngb-header-row, tr[ngb-header-row]", ["ngbHeaderRow"], {}, {}, never, never, true, never>;
}
/** Footer template container that contains the cell outlet. Adds the right class and role. */
declare class NgbFooterRow extends CdkFooterRow {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbFooterRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbFooterRow, "ngb-footer-row, tr[ngb-footer-row]", ["ngbFooterRow"], {}, {}, never, never, true, never>;
}
/** Data row template container that contains the cell outlet. Adds the right class and role. */
declare class NgbRow extends CdkRow {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbRow, "ngb-row, tr[ngb-row]", ["ngbRow"], {}, {}, never, never, true, never>;
}
/** Row that can be used to display a message when no data is shown in the table. */
declare class NgbNoDataRow extends CdkNoDataRow {
    _cellSelector: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbNoDataRow, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbNoDataRow, "ng-template[ngbNoDataRow]", never, {}, {}, never, never, true, never>;
}

/**
 * Enables the recycle view repeater strategy, which reduces rendering latency. Not compatible with
 * tables that animate rows.
 */
declare class NgbRecycleRows {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbRecycleRows, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbRecycleRows, "ngb-table[recycleRows], table[ngb-table][recycleRows]", never, {}, {}, never, never, true, never>;
}
/**
 * Wrapper for the CdkTable with Bootstrap styles.
 */
declare class NgbTable<T> extends CdkTable<T> {
    /** Overrides the need to add position: sticky on every sticky cell element in `CdkTable`. */
    protected needsPositionStickyOnElement: boolean;
    cdkTable: boolean;
    table: boolean;
    hover: boolean;
    striped: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTable<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTable<any>, "ngb-table, table[ngb-table]", ["ngbTable"], { "hover": { "alias": "hover"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; }, {}, never, ["caption", "colgroup, col", "*"], true, never>;
    static ngAcceptInputType_hover: unknown;
    static ngAcceptInputType_striped: unknown;
}

/**
 * @license
 * Original work Copyright Google LLC All Rights Reserved.
 * Modified work Copyright DatePoll-Systems
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * Column that simply shows text content for the header and row cells. Assumes that the table
 * is using the native table implementation (`<table>`).
 *
 * By default, the name of this column will be the header text and data property accessor.
 * The header text can be overridden with the `headerText` input. Cell values can be overridden with
 * the `dataAccessor` input. Change the text justification to the start or end using the `justify`
 * input.
 */
declare class NgbTextColumn<T> extends CdkTextColumn<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTextColumn<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTextColumn<any>, "ngb-text-column", never, {}, {}, never, never, true, never>;
}

declare class DfxTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DfxTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DfxTableModule, never, [typeof i1.CdkTableModule, typeof NgbTable, typeof NgbRecycleRows, typeof NgbHeaderCellDef, typeof NgbHeaderRowDef, typeof NgbColumnDef, typeof NgbCellDef, typeof NgbRowDef, typeof NgbFooterCellDef, typeof NgbFooterRowDef, typeof NgbHeaderCell, typeof NgbCell, typeof NgbFooterCell, typeof NgbHeaderRow, typeof NgbRow, typeof NgbFooterRow, typeof NgbNoDataRow, typeof NgbTextColumn], [typeof NgbTable, typeof NgbRecycleRows, typeof NgbHeaderCellDef, typeof NgbHeaderRowDef, typeof NgbColumnDef, typeof NgbCellDef, typeof NgbRowDef, typeof NgbFooterCellDef, typeof NgbFooterRowDef, typeof NgbHeaderCell, typeof NgbCell, typeof NgbFooterCell, typeof NgbHeaderRow, typeof NgbRow, typeof NgbFooterRow, typeof NgbNoDataRow, typeof NgbTextColumn]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DfxTableModule>;
}

export { DfxPaginationModule, DfxSortModule, DfxTableModule, NGB_PAGINATOR_DEFAULT_OPTIONS, NGB_PAGINATOR_INTL_PROVIDER, NGB_PAGINATOR_INTL_PROVIDER_FACTORY, NGB_SORT_DEFAULT_OPTIONS, NgbCell, NgbCellDef, NgbColumnDef, NgbFooterCell, NgbFooterCellDef, NgbFooterRow, NgbFooterRowDef, NgbHeaderCell, NgbHeaderCellDef, NgbHeaderRow, NgbHeaderRowDef, NgbNoDataRow, NgbPaginator, NgbPaginatorIntl, NgbRecycleRows, NgbRow, NgbRowDef, NgbSort, NgbSortHeader, NgbTable, NgbTableDataSource, NgbTextColumn, ngbSortHeaderColumnDef };
export type { NgbPaginatorDefaultOptions, NgbSortDefaultOptions, NgbSortable, PageEvent, Sort, SortDirection, SortHeaderArrowPosition };