import * as i0 from '@angular/core';
import { InputSignal, OnInit, OutputEmitterRef, Signal, InputSignalWithTransform, TemplateRef, InjectionToken, Type, TrackByFunction, WritableSignal, ComponentRef, ViewContainerRef } from '@angular/core';
import * as _ppwcode_ng_common from '@ppwcode/ng-common';
import { SelectionModel } from '@angular/cdk/collections';
import * as i8 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { FormArray, FormGroup } from '@angular/forms';
import * as i7 from '@angular/material/table';
import { MatTable, MatTableDataSource } from '@angular/material/table';
import * as i15 from '@angular/material/sort';
import { Sort } from '@angular/material/sort';
import * as i9 from '@angular/material/icon';
import * as i10 from '@angular/material/core';
import * as i11 from '@angular/material/checkbox';
import * as i12 from '@angular/material/button';
import * as i13 from '@angular/common';

declare enum Severity {
    success = "success",
    error = "error",
    warning = "warning",
    info = "info"
}

declare class MessageBarComponent {
    severity: InputSignal<Severity>;
    message: InputSignal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessageBarComponent, "ppw-message-bar", never, { "severity": { "alias": "severity"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ExpandableCardComponent implements OnInit {
    cardTitle: InputSignal<string | undefined>;
    cardDescription: InputSignal<string | undefined>;
    canBeCollapsed: InputSignal<boolean>;
    openAsExpanded: InputSignal<boolean>;
    panelOpenState: boolean;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableCardComponent, "ppw-expandable-card", never, { "cardTitle": { "alias": "cardTitle"; "required": false; "isSignal": true; }; "cardDescription": { "alias": "cardDescription"; "required": false; "isSignal": true; }; "canBeCollapsed": { "alias": "canBeCollapsed"; "required": false; "isSignal": true; }; "openAsExpanded": { "alias": "openAsExpanded"; "required": false; "isSignal": true; }; }, {}, never, ["[ppw-expandable-card-title]", "[ppw-expandable-card-description]", "*"], true, never>;
}

declare class SearchFilterComponent {
    submitDisabled: InputSignal<boolean>;
    clearDisabled: InputSignal<boolean>;
    allowReset: InputSignal<boolean>;
    searchLabel: InputSignal<string>;
    resetLabel: InputSignal<string>;
    performSearch: OutputEmitterRef<void>;
    clear: OutputEmitterRef<void>;
    protected executeSearch(): void;
    protected executeClear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchFilterComponent, "ppw-search-filter", never, { "submitDisabled": { "alias": "submitDisabled"; "required": false; "isSignal": true; }; "clearDisabled": { "alias": "clearDisabled"; "required": false; "isSignal": true; }; "allowReset": { "alias": "allowReset"; "required": false; "isSignal": true; }; "searchLabel": { "alias": "searchLabel"; "required": false; "isSignal": true; }; "resetLabel": { "alias": "resetLabel"; "required": false; "isSignal": true; }; }, { "performSearch": "performSearch"; "clear": "clear"; }, never, ["*"], true, never>;
}

/**
 * Enum containing the different column types supported by the DataTablesModule.
 */
declare enum ColumnType {
    /** A column that will display the value as it is given. */
    Text = "text",
    Date = "date",
    Number = "number",
    Template = "template"
}
/**
 * The representation of a column.
 * TRecord is the type of object in the items array.
 * TValue is the type of the resulting value.
 */
interface Column<TRecord, TValue> {
    /** The type of the column. */
    readonly type: ColumnType;
    /** The unique name of the column within a set of columns. */
    name: string;
    /** The label to display in the column header. */
    label: string;
    /** Whether the column should be sticky. */
    sticky: boolean;
    /** Whether the column should be sticky at the end of the row. */
    stickyEnd: boolean;
    /** Whether the column is sortable. */
    sortable: Signal<boolean>;
    /** Whether the sort clear should be disabled. */
    disableSortClear: Signal<boolean>;
    value?: string | ((record: TRecord) => TValue);
}

/**
 * This directive represents what a column should look like in the table.
 *
 * It can be used in the template, between the `ppw-table` tags.
 * @example
 * `<ppw-table [data]="myDataArray">
 *     <ppw-column name="name" label="Name" type="Text"></ppw-column>
 * </ppw-table>`
 */
declare class PpwColumnDirective<TRecord> {
    #private;
    /** The name of the column, this should be unique within the table. */
    name: InputSignal<string | keyof TRecord>;
    /** The type of the column, this determines the way its value is rendered and is optional if a cell template is set. */
    type: InputSignal<ColumnType | Lowercase<keyof typeof ColumnType>>;
    /** The label of the column, this is shown in the header of the column if no header template is set. */
    label: InputSignal<string | undefined>;
    /** Whether the column should be sticky. */
    sticky: InputSignalWithTransform<boolean, unknown>;
    /** Whether the column should be sticky at the end of the row. */
    stickyEnd: InputSignalWithTransform<boolean, unknown>;
    /** The formatting function to format number values. When not provided, the default from PPW_TABLE_OPTIONS is used. */
    numberFormatFn: InputSignal<((value: any) => string) | undefined>;
    /** The formatting function to format date values. */
    dateFormatFn: InputSignal<((value: any) => string) | undefined>;
    /** The name of the property to get the value from, or a custom function providing the value. */
    valueRetrieval: InputSignal<string | ((record: TRecord) => unknown) | undefined>;
    /** Whether the column is sortable. */
    sortable: InputSignalWithTransform<boolean, unknown>;
    /** Whether the sort clear should be disabled. */
    disableSortClear: InputSignalWithTransform<boolean, unknown>;
    /** Reference to the optional header cell template. */
    private headerCellDirective;
    /** Reference to the optional row cell template. */
    private columnCellDirective;
    /** Gets the template reference from the found header cell directive. */
    get headerTemplate(): TemplateRef<unknown> | undefined;
    /** Gets the number formatting function to use. This is the `numberFormatFn` input or the default from PPW_TABLE_OPTIONS. */
    private get numberFormatter();
    /** Gets the date formatting function to use. This is the `dateFormatFn` input or the default from PPW_TABLE_OPTIONS. */
    private get dateFormatter();
    columnDefinition: Signal<Column<TRecord, unknown> | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PpwColumnDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PpwColumnDirective<any>, "ppw-column", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "stickyEnd": { "alias": "stickyEnd"; "required": false; "isSignal": true; }; "numberFormatFn": { "alias": "numberFormatFn"; "required": false; "isSignal": true; }; "dateFormatFn": { "alias": "dateFormatFn"; "required": false; "isSignal": true; }; "valueRetrieval": { "alias": "valueRetrieval"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "disableSortClear": { "alias": "disableSortClear"; "required": false; "isSignal": true; }; }, {}, ["headerCellDirective", "columnCellDirective"], never, false, never>;
}

/**
 * Directive used to identify the template for the cell of a column.
 */
declare class PpwColumnCellDirective {
    templateRef: TemplateRef<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PpwColumnCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PpwColumnCellDirective, "[ppw-column-cell]", never, {}, {}, never, never, false, never>;
}

/**
 * Directive used to identify the template for the header of a column.
 */
declare class PpwColumnHeaderDirective {
    templateRef: TemplateRef<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PpwColumnHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PpwColumnHeaderDirective, "[ppw-column-header]", never, {}, {}, never, never, false, never>;
}

/**
 * Directive used to identify the template for when the table has an empty page.
 */
declare class PpwEmptyTablePageDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<PpwEmptyTablePageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PpwEmptyTablePageDirective, "[ppw-empty-page]", never, {}, {}, never, never, false, never>;
}

/**
 * Interface describing the options for a ppwcode table.
 */
interface PpwTableOptions<TRecord> {
    /**
     * Configuration for the header of the table.
     */
    header?: {
        /** Whether the header should stick to the top of the table when scrolling. */
        sticky?: boolean;
        /** Whether the header should be hidden. */
        hidden?: boolean;
        /** Whether the first row should have a top border. This is only applied when the header is hidden. */
        showFirstRowTopBorder?: boolean;
        /** CSS styles to conditionally apply to the header cells of the given columns. */
        styles?: Record<keyof Partial<TRecord> | string, () => {
            [key: string]: unknown;
        }>;
    };
    /**
     * Configuration for the footer of the table.
     */
    footer?: {
        /** Whether the header should stick to the top of the table when scrolling. */
        sticky?: boolean;
        /** CSS styles to conditionally apply to the header cells of the given columns. */
        styles?: Record<string, () => {
            [key: string]: unknown;
        }>;
    };
    /**
     * Configuration for the columns of the table.
     */
    columns?: {
        /**
         * The widths of the columns in the table.
         * The keys are the column names. Any string is allowed because column names are not limited to the keys of a record,
         * because we can have columns that are calculated from other columns.
         * The values are the widths in CSS units: px, %, em, rem, ...
         */
        widths?: Record<keyof Partial<TRecord> | string, string>;
        /** CSS styles to conditionally apply to the cells of the given columns. */
        styles?: Record<keyof Partial<TRecord> | string, (record: TRecord) => {
            [key: string]: unknown;
        }>;
        /** Column names to ignore the row click for. */
        ignoreClick?: string[];
    };
    /**
     * Configuration for the rows of the table.
     */
    rows?: {
        /** Whether the row should be highlighted on hover. */
        highlightOnHover?: boolean;
        /** Function to be executed when the row is clicked. */
        onClick?: (row: TRecord) => void;
        /** Function to be executed when the row is CTRL-clicked. */
        onCtrlClick?: (row: TRecord) => void;
        /** Disable selection of the current row. */
        disableRowSelection?: (row: TRecord) => boolean;
    };
}

declare const PPW_TABLE_DEFAULT_OPTIONS: InjectionToken<PpwTableDefaultOptions>;
interface PpwTableDefaultOptions {
    dateColumnFormatter?: (value: unknown) => string;
    numberColumnFormatter?: (value: unknown) => string;
    emptyPageComponent?: Type<unknown>;
}

interface TableRecord<T = unknown> {
    /** The initial record that was passed. */
    initialRecord: T;
    /** A local mapped representation of the record. */
    mappedValues: Record<string, unknown>;
    /** The value generated for the trackBy function. */
    trackByValue: unknown;
    /** Whether the record can be selected. */
    selectable: boolean;
}

interface SortChange {
    /** The name of the column that was sorted. */
    column: string;
    /** The direction of the sort. */
    direction: 'asc' | 'desc' | '';
}

declare const AbstractTableComponent_base: _ppwcode_ng_common.CanHandleSubscriptionsCtor & _ppwcode_ng_common.Constructor<object>;
declare abstract class AbstractTableComponent<TRecord, TData = FormArray<FormGroup> | Array<Record<string, unknown>>> extends AbstractTableComponent_base implements OnInit {
    #private;
    headerTemplates: Record<string | keyof TRecord, TemplateRef<unknown>>;
    data: InputSignal<TData>;
    footerData: InputSignal<Record<string, unknown> | undefined>;
    trackBy: InputSignal<TrackByFunction<TRecord>>;
    disableAnimations: InputSignal<boolean>;
    enableRowSelection: InputSignal<boolean>;
    enableRowDrag: InputSignal<boolean>;
    expandable: InputSignalWithTransform<boolean, unknown>;
    expandableTemplate: InputSignal<TemplateRef<{
        $implicit: TRecord;
    }> | undefined>;
    options: InputSignal<PpwTableOptions<TRecord> | undefined>;
    sort: InputSignal<Sort | undefined>;
    selectionChanged: OutputEmitterRef<TableRecord<TRecord>[]>;
    orderChanged: OutputEmitterRef<TableRecord<TRecord>[]>;
    sortChanged: OutputEmitterRef<SortChange>;
    emptyPageTemplate: Signal<TemplateRef<unknown> | undefined>;
    columnDirectives: Signal<readonly PpwColumnDirective<TRecord>[]>;
    table: Signal<MatTable<TRecord>>;
    columns: Signal<Array<Column<TRecord, unknown>>>;
    /** The names of the columns that are displayed. */
    columnNames: Signal<Array<string>>;
    protected readonly localRecords: Signal<TableRecord<TRecord>[]>;
    protected readonly selectableRows: Signal<TableRecord<TRecord>[]>;
    /** The data source for the material table. */
    dataSource: WritableSignal<MatTableDataSource<TableRecord<TRecord>>>;
    arrowPositions: Signal<Record<string, "before" | "after">>;
    selection: SelectionModel<TableRecord<TRecord>>;
    readonly isAllSelected: Signal<boolean>;
    readonly isSomeSelected: Signal<boolean>;
    protected readonly notUndefined: <T>(t?: T) => T;
    get emptyPageComponent(): Type<unknown> | undefined;
    /** Gets whether a custom height has been set by the --ppw-table-height CSS variable. */
    get hasFixedHeight(): boolean;
    /** Whether the given record is expanded. */
    isExpanded(record: TRecord): boolean;
    isRowSelectionDisabled(row: TableRecord<TRecord>): boolean;
    /** Selects all rows if they are not all selected; otherwise clear selection. */
    masterToggle(): void;
    ngOnInit(): void;
    trackByFn(_index: number, item: TableRecord<TRecord>): unknown;
    mapValue(column: Column<TRecord, unknown>, record: unknown): {} | undefined;
    executeRowClick(event: MouseEvent, record: TRecord, columnName: string): void;
    toggleExpand(record: TRecord): void;
    dropTable(event: CdkDragDrop<MatTableDataSource<TableRecord<TRecord>>, unknown>): void;
    handleSortChange(sort: Sort): void;
    /**
     * Maps the given items into a local key-value pair to be used within
     * the template. The original record is left intact so that it can still
     * be passed along where necessary.
     * @param items The items to map.
     */
    protected abstract _mapToLocalKeyValuePairs(items: TData, columns: Array<Column<TRecord, unknown>>, disabledFn?: (record: TRecord) => boolean): Array<TableRecord<TRecord>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTableComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTableComponent<any, any>, never, never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "footerData": { "alias": "footerData"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": true; "isSignal": true; }; "disableAnimations": { "alias": "disableAnimations"; "required": false; "isSignal": true; }; "enableRowSelection": { "alias": "enableRowSelection"; "required": false; "isSignal": true; }; "enableRowDrag": { "alias": "enableRowDrag"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "expandableTemplate": { "alias": "expandableTemplate"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; }, { "selectionChanged": "selectionChanged"; "orderChanged": "orderChanged"; "sortChanged": "sortChanged"; }, ["emptyPageTemplate", "columnDirectives"], never, true, never>;
}

declare class TableComponent<TRecord> extends AbstractTableComponent<TRecord, Array<Record<string, unknown>>> implements OnInit {
    /**
     * Maps the given items into a local key-value pair to be used within
     * the template. The original record is left intact so that it can still
     * be passed along where necessary.
     * @param items The items to map.
     */
    protected _mapToLocalKeyValuePairs(items: Array<Record<string, unknown>>, columns: Array<Column<TRecord, unknown>>, disabledFn?: (record: TRecord) => boolean): Array<TableRecord<TRecord>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "ppw-table", never, {}, {}, never, never, false, never>;
}

declare class FormTableComponent<TRecord> extends AbstractTableComponent<TRecord> implements OnInit {
    /**
     * Maps the given items into a local key-value pair to be used within
     * the template. The original record is left intact so that it can still
     * be passed along where necessary.
     * @param items The items to map.
     */
    protected _mapToLocalKeyValuePairs(items: FormArray<FormGroup>, columns: Array<Column<TRecord, unknown>>, disabledFn?: (record: TRecord) => boolean): Array<TableRecord<TRecord>>;
    addControl(control: FormGroup): void;
    removeControl(control: FormGroup): void;
    private refreshDataSource;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormTableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormTableComponent<any>, "ppw-form-table", never, {}, {}, never, never, false, never>;
}

/**
 * Defines that the implementation has the API of a cell component.
 *
 * Generic type TColumn is the corresponding configuration of the related column.
 * Generic type TValue is the type of value that is expected and defaults to any.
 *      This allows for type safety in the implementation where the component needs to
 *      manipulate the value it was given.
 */
interface IsCellComponent<TColumn extends Column<any, unknown>, TValue = any> {
    /** The row index of the record in the ngFor loop */
    rowIndex: Signal<number>;
    /** The configuration of the column the cell is related to. */
    column: Signal<TColumn>;
    /** The original record data the cell is rendered for. */
    record: Signal<{
        [key: string]: any;
    }>;
    /** The value for the cell component to continue with. */
    value: Signal<TValue>;
}

declare class DynamicCellDirective<TRecord> implements OnInit {
    private _viewContainerRef;
    column: InputSignal<Column<TRecord, any>>;
    record: InputSignal<Record<string, unknown>>;
    value: InputSignal<any>;
    rowIndex: InputSignal<number>;
    /** A reference to the instantiated component. */
    componentRef: ComponentRef<IsCellComponent<Column<TRecord, any>>>;
    private _componentTypeMap;
    constructor(_viewContainerRef: ViewContainerRef);
    ngOnInit(): void;
    /**
     * Creates a new instance of the component on the view container.
     */
    private _instantiateComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicCellDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicCellDirective<any>, "[ppwDynamicCell]", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "record": { "alias": "record"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PpwTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PpwTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PpwTableModule, [typeof TableComponent, typeof FormTableComponent, typeof PpwColumnDirective, typeof PpwColumnHeaderDirective, typeof PpwColumnCellDirective, typeof PpwEmptyTablePageDirective], [typeof i7.MatTableModule, typeof i8.CdkDropList, typeof i9.MatIconModule, typeof i8.CdkDragHandle, typeof i10.MatRippleModule, typeof i11.MatCheckboxModule, typeof i12.MatButtonModule, typeof i13.NgStyle, typeof DynamicCellDirective, typeof i8.CdkDrag, typeof i13.NgIf, typeof i13.NgForOf, typeof i13.NgTemplateOutlet, typeof i8.CdkDragPlaceholder, typeof i13.NgComponentOutlet, typeof i15.MatSortModule], [typeof TableComponent, typeof FormTableComponent, typeof PpwColumnDirective, typeof PpwColumnHeaderDirective, typeof PpwColumnCellDirective, typeof PpwEmptyTablePageDirective, typeof i15.MatSortModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PpwTableModule>;
}

declare class LoaderComponent {
    loading: InputSignal<boolean | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "ppw-loader", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * A model representing an action on a dashboard item.
 */
interface DashboardItemAction {
    /** The translation key of the label to show on the button. */
    labelKey: string;
    /** The function that will be executed when the action button is clicked. */
    clickFn: () => void;
}

/**
 * The model for an item that can be shown as a dashboard item.
 */
interface DashboardItem {
    /** The optiona fa icon class that will be used to render the dashboard item icon. */
    iconClass?: string;
    /** An optional template ref that will be rendered as the dashboard item content. */
    template?: TemplateRef<unknown>;
    /** The translation key for the dashboard item title. */
    titleKey: string;
    /** The translation key for the description that will be added to the dashboard item. */
    descriptionKey: string;
    /** The default action that will be executed when the icon or template of the dashboard item is clicked. */
    defaultAction?: DashboardItemAction;
    /** The actions that will be shown on the dashboard item. */
    actions?: DashboardItemAction[];
    /** An optional badge that can be shown on a dashboard item. */
    badgeContent?: string;
    /** Indicates in what direction the action buttons should be displayed */
    actionsDirection?: 'row' | 'column';
    /** Indicates how the action buttons should be aligned */
    actionsAlignment?: 'start' | 'center' | 'end';
}

interface DashboardOptions {
    cardsAlignment: 'left' | 'center';
}

declare class DashboardItemsTableComponent {
    dashboardItems: InputSignal<Array<DashboardItem>>;
    dashboardOptions: InputSignal<DashboardOptions | undefined>;
    executeAction: OutputEmitterRef<DashboardItemAction | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardItemsTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardItemsTableComponent, "ppw-dashboard-items-table", never, { "dashboardItems": { "alias": "dashboardItems"; "required": true; "isSignal": true; }; "dashboardOptions": { "alias": "dashboardOptions"; "required": false; "isSignal": true; }; }, { "executeAction": "executeAction"; }, never, never, true, never>;
}

export { DashboardItemsTableComponent, ExpandableCardComponent, FormTableComponent, LoaderComponent, MessageBarComponent, PPW_TABLE_DEFAULT_OPTIONS, PpwColumnCellDirective, PpwColumnDirective, PpwColumnHeaderDirective, PpwEmptyTablePageDirective, PpwTableModule, SearchFilterComponent, Severity, TableComponent };
export type { DashboardItem, DashboardItemAction, DashboardOptions, PpwTableDefaultOptions, PpwTableOptions, SortChange, TableRecord };