import * as i0 from '@angular/core';
import { EventEmitter, OnInit, OnDestroy, QueryList, AfterViewInit, ElementRef, KeyValueDiffers, KeyValueDiffer, KeyValueChangeRecord, DoCheck, DestroyRef, ChangeDetectorRef } from '@angular/core';
import * as i15 from '@angular/common';
import { CurrencyPipe } from '@angular/common';
import * as i25 from '@sowatech/shared/ds-datasource';
import { AggregateFunctionFieldConfig, FilterOperator, AggregateFunctionConfig, DatasourceComponent, CSVConfig } from '@sowatech/shared/ds-datasource';
import { LoggerService } from '@sowatech/shared/logger';
import { ScrollEvent } from '@sowatech/shared/scheduler';
import { SharedConfigService, ColumnType, TextAlignType, PaginationInfoVariant, SwtGridDefaultConfig, ShowDetailMethod, IconAlignType } from '@sowatech/shared/shared-config';
import * as i24 from '@sowatech/shared/swt-controls';
import { LoadingIndicatorComponent, IQuillConfiguration, QuillToolbarDefaultType, IQuillToolbarConfiguration, ColorPickerConfiguration } from '@sowatech/shared/swt-controls';
import * as i26 from '@sowatech/shared/swt-dragula';
import { DragulaService } from '@sowatech/shared/swt-dragula';
import * as i36 from '@sowatech/shared/utilities';
import { I18nService } from '@sowatech/shared/utilities';
import { ModalDirective, BsModalRef, BsModalService } from 'ngx-bootstrap/modal';
import * as i31 from 'ngx-scrollbar';
import { NgScrollbar } from 'ngx-scrollbar';
import { UserPropertiesStorageService } from '@sowatech/shared/user-properties-storage';
import { SelectItem, GroupedSelectItem, SelectColor, SelectItemGroup } from '@sowatech/shared/@types';
import * as i16 from '@ng-select/ng-select';
import { NgOption } from '@ng-select/ng-select';
import { Subscription, Observable, Subject } from 'rxjs';
import { QuillModules } from 'ngx-quill';
import * as i19 from '@sowatech/shared/dialogs';
import { DialogInitDirective } from '@sowatech/shared/dialogs';
import * as i29 from 'ng-keyboard-shortcuts';
import * as i20 from 'ngx-bootstrap/dropdown';
import * as i22 from 'ngx-bootstrap/popover';
import * as i23 from 'ngx-bootstrap/timepicker';
import * as i21 from 'ngx-bootstrap/typeahead';
import * as i17 from '@angular/forms';
import { NgForm } from '@angular/forms';
import * as i18 from '@angular/router';
import * as i27 from 'ngx-mask';
import * as i28 from '@sowatech/shared/no-double-click';
import * as i30 from '@sowatech/shared/no-edit-button';
import * as i32 from '@sowatech/shared/template';
import * as i33 from '@sowatech/shared/buttons';
import * as i34 from '@sowatech/shared/layout';
import * as i35 from '@sowatech/shared/typed-template';

declare class ColVisibilityService {
    private userPropertiesStorage;
    constructor(userPropertiesStorage: UserPropertiesStorageService);
    private storageKey;
    isColumnVisible(columnKey: string, hiddenByDefault: boolean | undefined): boolean;
    updateColumnVisibility(visibleColumns: Column[], hiddenColumns: Column[]): void;
    hiddenColumnsChanged: EventEmitter<string[]>;
    private deleteFromStore;
    private setHidden;
    private setVisible;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColVisibilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ColVisibilityService>;
}
type Column = {
    columnKey: string;
    hiddenByDefault: boolean;
};

declare abstract class ColSelectDialogComponentBase {
    component: ColSelectDialogComponent;
    dialog: ModalDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColSelectDialogComponentBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColSelectDialogComponentBase, never, never, { "component": { "alias": "component"; "required": false; }; }, {}, never, never, true, never>;
}
declare class ColSelectDialogInspiniaComponent extends ColSelectDialogComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<ColSelectDialogInspiniaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColSelectDialogInspiniaComponent, "col-select-dialog-inspinia", never, {}, {}, never, never, false, never>;
}
declare class ColSelectDialogSneatComponent extends ColSelectDialogComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<ColSelectDialogSneatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColSelectDialogSneatComponent, "col-select-dialog-sneat", never, {}, {}, never, never, false, never>;
}

declare class ColSelectDialogComponent implements OnInit, OnDestroy {
    private colVisibilityService;
    bsModalRef: BsModalRef;
    constructor(colVisibilityService: ColVisibilityService, sharedConfig: SharedConfigService, bsModalRef: BsModalRef);
    ngOnInit(): void;
    private readonly subscriptions;
    ngOnDestroy(): void;
    dialogTitle: string;
    disableAnimation: boolean;
    template: QueryList<ColSelectDialogComponentBase>;
    onSubmit: EventEmitter<string[]>;
    get isConfigured(): boolean;
    dialogFields: DialogField$1[];
    editItem: ColumnVisibility;
    private createColumnVisibility;
    cancelDialog(): void;
    submitDialog(): void;
    private onSubmitColumnVisiblity;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColSelectDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColSelectDialogComponent, "col-select-dialog", never, {}, { "onSubmit": "onSubmit"; }, never, never, false, never>;
}
type ColumnVisibility = {
    [fieldname: string]: boolean;
};
interface DialogField$1 {
    columnKey: string;
    text: string;
    type: string;
    hiddenByDefault: boolean;
}

type HeaderTitleGroups = Record<string, IHeaderTitleGroup>;
type GridLookup = Array<SelectItem> | Array<string>;
type GridSpanVariant = 'label' | 'icon' | 'progress' | 'stackedProgress';
type GridColumnType = ColumnType | 'buttons' | 'empty' | 'lookup';
/**
 * das zugewiesene Feld kann nur ein Feldname von T sein, wobei der zugewiesene Typ für dieses Feld V ist
 */
type KeyWithType<T, V> = {
    [K in keyof T]-?: T[K] extends V ? K : never;
}[keyof T];
/**
 * das zugewiesene Feld kann nur ein Feldname von T mit string value sein
 */
type FieldnameWithStringValue<T> = KeyWithType<T, string>;
type FieldnameWithBooleanValue<T> = KeyWithType<T, boolean>;
type FieldnameWithRecordValue<T> = KeyWithType<T, Record<string, unknown>>;
type ItemId = any;
declare class GridColumn<ListItem = any> implements AggregateFunctionFieldConfig<ListItem> {
    text?: string;
    title?: string;
    fieldname?: Extract<keyof ListItem, string>;
    headerTitleGroup?: string;
    hideFieldValue?: boolean;
    type?: GridColumnType;
    lookups?: GridLookup;
    trueValueText?: string;
    falseValueText?: string;
    unit?: string;
    digitInfo?: string;
    dateFormat?: string;
    buttons?: Array<GridColumnButton<ListItem>>;
    buttonsAsDropdown?: string;
    buttonsAsDropdownClass?: string;
    spans?: Array<GridColumnSpan<ListItem>>;
    titleSpans?: Array<GridTitleSpan<ListItem>>;
    minWidth?: string;
    width?: string;
    textAlign?: TextAlignType;
    bodyClass?: string;
    bodyClassFieldname?: FieldnameWithStringValue<ListItem>;
    headerClass?: string;
    allowFilter?: boolean;
    allowSort?: boolean;
    filterOperator?: FilterOperator;
    /**
     * Filtervariante bei Lookups
     * @default 'single'
     */
    filterSelectOption?: 'single' | 'multi';
    edit?: boolean;
    /** Aggregatfunktionen über Items (siehe includedAggregateData). Ergebnis im Tooltip oder Footer. Klappt nur mit Zahlen */
    aggregateFunctions?: AggregateFunctionGridConfig[];
    /** Wenn true: Spalte ist hidden und muss über den visibility-Dialog explizit eingeblendet werden */
    hiddenByDefault?: boolean;
    /**
     * welche Daten sollen für aggregateFunctions verwendet werden?
     *
     * @default 'all'
     */
    includedAggregateData?: 'all' | 'selected';
    groupBy?: boolean;
}
declare class GridColumnButton<ListItem = any> {
    ident?: string;
    text?: string;
    tooltip?: string;
    buttonClass?: string;
    iconClass?: string;
    disabledFieldname?: FieldnameWithBooleanValue<ListItem>;
    buttonClassFieldname?: FieldnameWithStringValue<ListItem>;
    iconClassFieldname?: FieldnameWithStringValue<ListItem>;
    /**
     * Beispiel:
     * `spans: [{ text: 'Löschen', ident: 'DELETE', onClick: id => this.delete(id) }]`
     */
    onClick?: (itemId: ItemId | null) => void;
}
declare class GridTitleSpan<ListItem = any> {
    class?: string;
    text?: string;
    title?: string;
    positionBefore?: boolean;
    color?: string;
    color2?: string;
    backgroundColor?: string;
    isIcon?: boolean;
    variant?: GridSpanVariant;
    routerLink?: string;
    /** Zusätzliche QueryParams für den RouterLink*/
    queryParams?: Record<string, unknown>;
    /** soll bei variant = 'progress' der Wert in % angezeigt werden? default: true */
    showProgressPercent?: boolean;
    stackedProgressBars?: IStackedProgressBar<ListItem>[];
    ident?: string;
    onClick?: () => void;
}
declare class GridColumnSpan<ListItem = any> {
    class?: string;
    classFieldname?: FieldnameWithStringValue<ListItem>;
    text?: string;
    textFieldname?: Extract<keyof ListItem, string>;
    title?: string;
    titleFieldname?: Extract<keyof ListItem, string>;
    positionBefore?: boolean;
    color?: string;
    colorFieldname?: FieldnameWithStringValue<ListItem>;
    color2?: string;
    color2Fieldname?: FieldnameWithStringValue<ListItem>;
    backgroundColor?: string;
    backgroundColorFieldname?: FieldnameWithStringValue<ListItem>;
    isIcon?: boolean;
    variant?: GridSpanVariant;
    routerLink?: string;
    /** Feldname mit Routerlink (als string); if!=null wird in <a> tag mit Routerlink gerendert */
    routerLinkFieldname?: FieldnameWithStringValue<ListItem>;
    /** Zusätzliche QueryParams für den RouterLink*/
    queryParams?: Record<string, unknown>;
    /** Feldname mit zusätzlichen QueryParams für den RouterLink*/
    queryParamsFieldname?: FieldnameWithRecordValue<ListItem>;
    /** soll bei variant = 'progress' der Wert in % angezeigt werden? default: true */
    showProgressPercent?: boolean;
    stackedProgressBars?: IStackedProgressBar<ListItem>[];
    ident?: string;
    /**
     * Beispiel:
     * `buttons: [{ text: 'Löschen', ident: 'DELETE', onClick: id => this.delete(id) }]`
     */
    onClick?: (itemId: ItemId | null) => void;
}
declare class GridConfiguration<ListItem = any> {
    columns: Array<GridColumn<ListItem>>;
    idfield?: Extract<keyof ListItem, string>;
    small?: boolean;
    gridStoreKey?: string;
    gridClass?: string;
    allowFilter?: boolean;
    allowSort?: boolean;
    allowPaging?: boolean;
    pageSizes?: number[];
    paginationInfoVariant?: PaginationInfoVariant;
    allowPrintDownload?: boolean;
    printTitle?: string;
    rowClassFieldName?: keyof ListItem;
    rowDetailClassFieldName?: keyof ListItem;
    allowSelectPageSize?: boolean;
    allowMultiSelect?: boolean;
    disableFieldName?: Extract<keyof ListItem, string>;
    tableHover?: boolean;
    showSelectCheckBoxes?: boolean;
    showEmptyGrid?: boolean;
    emptyGridText?: string;
    dragulaBag?: string;
    filterFieldsVisible?: boolean;
    hideColSelectBtn?: boolean;
    headerTitleGroups?: HeaderTitleGroups;
}
type AggregateFunctionGridConfig = AggregateFunctionConfig & {
    /** @default true */
    showInTooltip?: boolean;
    /** @default false */
    showInFooterRow?: boolean;
};
interface IHeaderTitleGroup {
    text: string;
    title?: string;
}
interface IStackedProgressBar<ListItem = any> {
    value?: string;
    valueFieldname?: Extract<keyof ListItem, string>;
    class?: string;
    classFieldName?: string;
}

declare class GridDropEvent {
    sourceContainer: HTMLElement;
    destinationContainer: HTMLElement;
    dropElement: HTMLElement;
    nextElement?: HTMLElement;
    nextItem?: any;
    editItem: any;
}
declare class GridDropRemoveEvent {
    sourceContainer: HTMLElement;
    editItem: any;
}
declare class RowClickEvent {
    $event: MouseEvent;
    itemId: any;
}
declare class Html5DragDropEvent {
    $event: DragEvent;
    itemId: any;
}
declare class GridColumnButtonEvent {
    buttonIdent: string;
    itemId: any;
    event: MouseEvent;
}
declare class SpanClickEvent {
    ident: string;
    event: MouseEvent;
    listItem: any;
}

type OnlyStringKeys = Record<string, any>;
type Id = any;
declare class GridComponent<ListItem extends OnlyStringKeys = any> implements OnInit, OnDestroy, AfterViewInit {
    private logger;
    private dragulaService;
    locale: string;
    private config;
    private colVisibilityService;
    private currencyPipe;
    private modalService;
    private i18n;
    constructor(logger: LoggerService, dragulaService: DragulaService, locale: string, config: SwtGridDefaultConfig, colVisibilityService: ColVisibilityService, currencyPipe: CurrencyPipe, modalService: BsModalService, i18n: I18nService);
    private bsModalRef?;
    private readonly destroyRef;
    private printService;
    readonly selectAllRowsLabel: string;
    readonly selectRowLabel: string;
    private datePipe;
    private decimalPipe;
    private subscriptions;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private onColVisibilityChanged;
    onKeydownHandler(event: KeyboardEvent): void;
    onEnterPressed(): void;
    /**
     * @deprecated clickOnFocusedRow() benutzen
     */
    clickOnFocuedRow(): void;
    clickOnFocusedRow(): void;
    onKeyUp(): void;
    onKeyDown(): void;
    get datasourceHasExternalRefresh(): boolean;
    gridId: string;
    gridIdPrefix: string;
    idfield: string;
    set setGridId(value: string);
    cyTotalRefreshCounter: i0.WritableSignal<number>;
    cyCurrentRefreshCounter: i0.WritableSignal<number>;
    set setListDatasource(value: DatasourceComponent);
    stickyHeader: boolean;
    name: string;
    small: boolean;
    allowKeyboardShortCuts: boolean;
    minHeight: string;
    /**
     * Max-Height of table excluding pagination.
    */
    maxHeightTable: string;
    /**
    * Obsolete. Max-Height of entire component including pagination, filter info etc. Use maxHeightTable instead.
    */
    maxHeight: string;
    rowHeight: number;
    filterRowHeight: number;
    headerRowHeight: number;
    headerTitleGroups: HeaderTitleGroups;
    gridStoreKey: string;
    hideColSelectBtn: boolean;
    gridClass: string;
    allowCSVDownload: boolean;
    csvFileName: string;
    csvConfig: CSVConfig;
    allowFilter: boolean;
    allowSort: boolean;
    allowPaging: boolean;
    showSelectedIdsNotFoundWarning: boolean;
    showRowDetail: boolean;
    showDetailMethod: ShowDetailMethod;
    paginationInfoVariant: PaginationInfoVariant;
    allowPrintDownload: boolean;
    printTitle: string;
    rowClassFieldName?: keyof ListItem;
    rowDetailClassFieldName?: keyof ListItem;
    allowSelectPageSize: boolean;
    set _pageSizes(values: number[]);
    pageSizes: number[];
    allowMultiSelect: boolean;
    /** Bool-Fieldname des Models der angibt ob Select für Zeile disabled wird*/
    disableSelectFieldName: Extract<keyof ListItem, string>;
    showEmptyGrid: boolean;
    emptyGridText: string;
    filterFieldsVisible: boolean;
    sortItemAlign: IconAlignType;
    html5Draggable: string;
    onHtml5DragStart: EventEmitter<Html5DragDropEvent>;
    dragulaBag: i0.InputSignal<string>;
    dragulaShowIcon: i0.InputSignal<boolean>;
    dragulaOnlyIconDrag: i0.InputSignal<boolean>;
    protected readonly dragulaDragHandleClass: i0.Signal<string>;
    private setDragulaOptions;
    private getDragulaOptions;
    private dragulaSubscriptions;
    private setDragulaSubscriptions;
    private setDatasourceFixedSortItems;
    showSelectCheckBoxes: boolean;
    tableHover: boolean;
    set setConfig(value: GridConfiguration<ListItem>);
    onButtonClicked: EventEmitter<GridColumnButtonEvent>;
    onRowClicked: EventEmitter<RowClickEvent>;
    onDrop: EventEmitter<GridDropEvent>;
    onDragulaRemove: EventEmitter<GridDropRemoveEvent>;
    /** nur für showDetailMethod = 'dropdown' */
    detailOpened: EventEmitter<any>;
    loadingIndicator: LoadingIndicatorComponent;
    filterItems: ElementRef<HTMLElement>;
    table: ElementRef;
    swtGridDiv: ElementRef;
    headerTitleGroupColumns?: HeaderTitleGroupCol[];
    showFooter: boolean;
    private readonly firstItemsOfGroupSignal;
    get firstItemsOfGroup(): Id[];
    focusGrid(): void;
    private readonly datasource;
    get listDatasource(): DatasourceComponent<ListItem>;
    set listDatasource(ds: DatasourceComponent<ListItem>);
    private allColumns;
    set columns(allColumns: GridColumn<ListItem>[]);
    setFocusedFilter(fieldName: string): void;
    private readonly visibleColumnsSignal;
    get visibleColumns(): GridColumn<ListItem>[];
    get numOfVisibleColumns(): number;
    private get extraColumnCount();
    get rowCursorClass(): string;
    private readonly groupByColumnsSignal;
    get groupByColumns(): GridColumn<ListItem>[];
    get groupByColumn(): GridColumn<ListItem>;
    get grouped(): boolean;
    private prepareHeaderGroupColumns;
    private prepareColumns;
    configureGrid(config: GridConfiguration<ListItem>): void;
    getData(): object[];
    downloadCSV(): void;
    downloadCsvWithData(data: ListItem[]): void;
    private getCSVColumn;
    displayText(listItem: any, column: GridColumn<ListItem>): string;
    getLookupTextColumn(listItem: any, column: GridColumn<ListItem>): string;
    allowSortColumn(column: GridColumn<ListItem>): boolean;
    allowFilterColumn(column: GridColumn<ListItem>): boolean;
    getFilterOperator(column: GridColumn<ListItem>): string;
    private autoDetectIdFieldname;
    private getListItemId;
    buttonClicked(event: MouseEvent, ident: string, listItem: any): void;
    spanClicked(event: SpanClickEvent): void;
    rowClick(event: MouseEvent, listItem: any): void;
    private onBeforeDatasourceRefresh;
    private onAfterDatasourceRefresh;
    private onFocus;
    toggleGridDetail(listItemId: Id): void;
    setRowDetailId(listItemId: Id): void;
    html5DragStart(event: DragEvent, listItem: ListItem): void;
    isSelected(listItem: ListItem): boolean;
    isFocused(listItem: ListItem): boolean;
    /** Die ID des geöffneten Grid Details */
    detailId?: Id;
    closeDetail(): void;
    closeDetailByDropDown(event?: Event): void;
    isRowDetailIdOpen(listItemId: Id): boolean;
    isRowDetailOpen(listItem: ListItem): boolean;
    openDetail(event: Event, listItem: ListItem): void;
    visibilityKey(gridColumn: GridColumn): string;
    colSelectDialog: ColSelectDialogComponent;
    showColSelectDialog(): void;
    columnClass(column: GridColumn<ListItem>, listItem: ListItem): string;
    getDefaultColumnTextAlignment(type?: GridColumnType): any;
    spansBefore(spans: GridColumnSpan[] | GridTitleSpan[]): Array<GridColumnSpan<ListItem>>;
    spansAfter(spans: GridColumnSpan[] | GridTitleSpan[]): Array<GridColumnSpan<ListItem>>;
    getButtonClass(listItem: ListItem, btn: GridColumnButton<ListItem>): string;
    getButtonIconClass(listItem: ListItem, btn: GridColumnButton<ListItem>): string;
    private onRowDrop;
    private onRowRemove;
    fieldValueModelChange(event: any, gridColumn: GridColumn<ListItem>, listItem: ListItem): void;
    getSelectOptionValue(lookup: unknown): unknown;
    private getColumnsByColVisibility;
    private formatAggregate;
    getAggregateFooterText(col: GridColumn<ListItem>): string;
    getAggregateTitleText(col: GridColumn<ListItem>): string;
    getEditColLabel(col: GridColumn<ListItem>): string;
    private updateShowFooter;
    private setDefaultConfigurations;
    printGrid(): void;
    private getNode;
    readonly scrollbar: i0.Signal<NgScrollbar>;
    private scrollEventBlocked;
    scrollToPosition(posX: number, posY: number): void;
    scrolledToPosition: EventEmitter<ScrollEvent>;
    scroll(event: any): void;
    private calcFirstItemsOfGroups;
    isFirstItemOfGroup(item: ListItem): boolean;
    columnTemplateParam: {
        listItem: ListItem;
        column: GridColumn<ListItem>;
    };
    getInputType(type: GridColumnType): "number" | "text" | "date" | "email" | "tel" | "buttons" | "checkbox" | "url" | "empty" | "lookup" | "datetime-local";
    static ɵfac: i0.ɵɵFactoryDeclaration<GridComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridComponent<any>, "swt-grid", never, { "idfield": { "alias": "idfield"; "required": false; }; "setGridId": { "alias": "id"; "required": false; }; "setListDatasource": { "alias": "datasource"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "name": { "alias": "name"; "required": false; }; "small": { "alias": "small"; "required": false; }; "allowKeyboardShortCuts": { "alias": "allowKeyboardShortCuts"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxHeightTable": { "alias": "maxHeightTable"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "filterRowHeight": { "alias": "filterRowHeight"; "required": false; }; "headerRowHeight": { "alias": "headerRowHeight"; "required": false; }; "headerTitleGroups": { "alias": "headerTitleGroups"; "required": false; }; "gridStoreKey": { "alias": "store-key"; "required": false; }; "hideColSelectBtn": { "alias": "hideColSelectBtn"; "required": false; }; "gridClass": { "alias": "gridClass"; "required": false; }; "allowCSVDownload": { "alias": "allowCSVDownload"; "required": false; }; "csvFileName": { "alias": "csvFileName"; "required": false; }; "csvConfig": { "alias": "csvConfig"; "required": false; }; "allowFilter": { "alias": "allowFilter"; "required": false; }; "allowSort": { "alias": "allowSort"; "required": false; }; "allowPaging": { "alias": "allowPaging"; "required": false; }; "showSelectedIdsNotFoundWarning": { "alias": "showSelectedIdsNotFoundWarning"; "required": false; }; "showRowDetail": { "alias": "showRowDetail"; "required": false; }; "showDetailMethod": { "alias": "showDetailMethod"; "required": false; }; "paginationInfoVariant": { "alias": "paginationInfoVariant"; "required": false; }; "allowPrintDownload": { "alias": "allowPrintDownload"; "required": false; }; "printTitle": { "alias": "printTitle"; "required": false; }; "rowClassFieldName": { "alias": "rowClassFieldName"; "required": false; }; "rowDetailClassFieldName": { "alias": "rowDetailClassFieldName"; "required": false; }; "allowSelectPageSize": { "alias": "allowSelectPageSize"; "required": false; }; "_pageSizes": { "alias": "pageSizes"; "required": false; }; "allowMultiSelect": { "alias": "allowMultiSelect"; "required": false; }; "disableSelectFieldName": { "alias": "disableSelectFieldName"; "required": false; }; "showEmptyGrid": { "alias": "showEmptyGrid"; "required": false; }; "emptyGridText": { "alias": "emptyGridText"; "required": false; }; "filterFieldsVisible": { "alias": "filterFieldsVisible"; "required": false; }; "sortItemAlign": { "alias": "sortItemAlign"; "required": false; }; "html5Draggable": { "alias": "html5Draggable"; "required": false; }; "dragulaBag": { "alias": "dragulaBag"; "required": false; "isSignal": true; }; "dragulaShowIcon": { "alias": "dragulaShowIcon"; "required": false; "isSignal": true; }; "dragulaOnlyIconDrag": { "alias": "dragulaOnlyIconDrag"; "required": false; "isSignal": true; }; "showSelectCheckBoxes": { "alias": "showSelectCheckBoxes"; "required": false; }; "tableHover": { "alias": "table-hover"; "required": false; }; "setConfig": { "alias": "config"; "required": false; }; }, { "onHtml5DragStart": "onHtml5DragStart"; "onButtonClicked": "onButtonClicked"; "onRowClicked": "onRowClicked"; "onDrop": "onDrop"; "onDragulaRemove": "onDragulaRemove"; "detailOpened": "detailOpened"; "scrolledToPosition": "scrolledToPosition"; }, never, ["*"], false, never>;
}
declare class HeaderTitleGroupCol implements IHeaderTitleGroup {
    key: string | null;
    span: number;
    constructor(key: string | null, span?: number, data?: IHeaderTitleGroup);
    text: string;
    title: string;
    get isEmpty(): boolean;
    static get empty(): HeaderTitleGroupCol;
}

declare class GridCellSpanComponent {
    spans: GridColumnSpan[];
    listItem?: unknown;
    spanClick: EventEmitter<SpanClickEvent>;
    private readListItem;
    private joinedString;
    spanText(span: GridColumnSpan): string;
    spanNumber(span: GridColumnSpan): number;
    spanNumberProgressBar(stackedProgressBar: IStackedProgressBar): number;
    spanTitle(span: GridColumnSpan): string;
    spanClass(span: GridColumnSpan): string;
    spanClassProgressBar(stackedProgressBar: IStackedProgressBar): string;
    colorValue(span: GridColumnSpan, fieldType: string): string;
    spanRouterLink(span: GridColumnSpan): string;
    spanQueryParams(span: GridColumnSpan): Record<string, unknown>;
    isClickable(span: GridColumnSpan): string;
    spanClicked(span: GridColumnSpan, event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridCellSpanComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridCellSpanComponent, "grid-cell-span", never, { "spans": { "alias": "spans"; "required": true; }; "listItem": { "alias": "listItem"; "required": false; }; }, { "spanClick": "spanClick"; }, never, never, false, never>;
}
declare class GridCellSpanRouterLinkComponent {
    readonly routerLink: i0.InputSignalWithTransform<string[], string>;
    readonly queryParams: i0.InputSignal<Record<string, unknown>>;
    protected handleClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridCellSpanRouterLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridCellSpanRouterLinkComponent, "grid-cell-span-router-link", never, { "routerLink": { "alias": "routerLink"; "required": true; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
}

declare class MultiSelectFilterComponent implements AfterViewInit {
    readonly lookups: i0.InputSignalWithTransform<NgOption[], GridLookup>;
    readonly fieldNames: i0.InputSignal<string | string[]>;
    readonly datasource: i0.InputSignal<DatasourceComponent<any, any>>;
    private readonly datasourceFilterItems;
    protected value: i0.Signal<string[]>;
    private readonly filterOperator;
    private readonly destryRef;
    ngAfterViewInit(): void;
    private transformGridLookup;
    protected setFilter(selection: NgOption[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectFilterComponent, "multi-select-filter", never, { "lookups": { "alias": "lookups"; "required": true; "isSignal": true; }; "fieldNames": { "alias": "fieldNames"; "required": true; "isSignal": true; }; "datasource": { "alias": "datasource"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

/**key for dynamic lookups, which are provided during dialog.show as a dictionary[lookupsKey,Array<SelectItem>]*/
type lookupsKey = string;
type Lookups = Array<SelectItem | GroupedSelectItem> | Array<SelectColor>;
type FieldType = 'text' | 'number' | 'date' | 'dateInterval' | 'boolean' | 'textarea' | 'password' | 'password-with-confirm' | 'email' | 'tel' | 'divider' | 'buttons' | 'info-text' | 'time' | 'lru' | 'hidden' | 'color-select' | 'money';
/**the type of control. in most cases this is equal to type of field but can differ (e.g. controltype "select")*/
type ControlType = 'text' | 'number' | 'date' | 'dateInterval' | 'dateInput' | 'checkbox' | 'textarea' | 'password' | 'password-with-confirm' | 'email' | 'tel' | 'select' | 'divider' | 'buttons' | 'grid' | 'info-text' | 'time' | 'dropdown-grid' | 'hidden' | 'rich-text' | 'color-picker' | 'money';
/**this class is used to configure the dialog*/
declare class DialogField<DTO = any> {
    fieldname?: Extract<keyof DTO, string>;
    type?: FieldType;
    /** Nicht manuell setzen!
     * wird intern aus type, controlTypeVariant, und vorhandenen lookups ermittelt. Im Regelfall identisch zu type
     * */
    controlType?: ControlType;
    /** wenn abweichend vom standard zb bei datePicker / dateInput */
    controlTypeVariant?: 'input';
    text?: string;
    unit?: string;
    placeholder?: string;
    help?: string;
    required?: boolean;
    /** Zweiter Feldname bei mehrteiligen Inputs wie z.B. dateInterval*/
    fieldname2?: Extract<keyof DTO, string>;
    /** Zweiter Text bei mehrteiligen Inputs wie z.B. dateInterval*/
    text2?: string;
    /** Zweiter Hilfetext bei mehrteiligen Inputs wie z.B. dateInterval*/
    help2?: string;
    /** Zweites Required bei mehrteiligen Inputs wie z.B. dateInterval*/
    required2?: boolean;
    maxLength?: number;
    default?: any;
    trueValueText?: string;
    falseValueText?: string;
    min?: number;
    max?: number;
    showSpinnerButtons?: boolean;
    calendarWeekVisible?: boolean;
    lookUps?: Lookups | Array<string> | lookupsKey;
    onLookUp?: (lookupItems: Array<SelectItem>, editItem: DTO) => Array<SelectItem>;
    onChange?: (editItem: any, previousValue: any) => void;
    multiSelectLookups?: boolean;
    radioLookups?: boolean;
    /** multi-lru async SelectItem loading */
    lookUpSearchFn?: (term: string) => Promise<SelectItem[]>;
    /** text for empty lookup */
    addEmptyLookup?: string;
    /** Felder mit  abhängigen selects => leert Value und cached lookUps des fieldnames beim change */
    dependentSelectFieldnames?: Array<Extract<keyof DTO, string>>;
    fieldnamePasswordConfirm?: Extract<keyof DTO, string>;
    autofocus?: boolean;
    hideIf?: (editItem: any) => boolean;
    buttons?: Array<DialogFieldButton>;
    grid?: DialogGridConfiguration;
    textMask?: TextMaskConfig;
    richText?: RichTextConfiguration;
    colorPicker?: ColorPickerConfiguration;
    zIndex?: number;
    /**optional: direktes setzen eines style im Eingabe-Control */
    controlStyle?: string;
    /** internal*/
    hasError?: boolean;
    cssClass?: string;
}
declare class TextMaskConfig {
    mask?: string;
    showMaskTyped?: boolean;
    patterns?: {
        [character: string]: {
            pattern: RegExp;
            optional?: boolean;
            symbol?: string;
        };
    };
}
declare class DialogFieldCategory<DTO = any> {
    name: string;
    dialogFields: DialogField<DTO>[];
    hideIf?: (editItem: any) => boolean;
    active?: boolean;
}
declare class DialogDynamicList {
    key: string;
    lookupItems?: Lookups;
    datasource?: DatasourceComponent;
}
declare class DialogFieldButton {
    onButtonClicked?: (editItem: any) => void;
    text?: string;
    tooltip?: string;
    buttonClass?: string;
    iconClass?: string;
    position?: 'form' | 'footer-before' | 'footer-after';
    submitDialog?: boolean;
    submitResult?: string;
    width?: `${number}px` | `${number}em` | `${number}%` | 'auto';
}
declare class DialogGridConfiguration extends GridConfiguration {
    datasource: DatasourceComponent | lookupsKey;
    /**
     * wenn gesetzt wird, wird das Grid als DropDown dargestellt
     */
    showAsDropDownFieldName?: string;
    onDropdownGridShown?: (editItem: any, fieldname: string, datasource: DatasourceComponent) => void;
    displayFieldValue?: string;
    pageSize?: number;
}
declare class RichTextConfiguration implements IQuillConfiguration {
    /**
        default: 'html'
     */
    format?: 'object' | 'html' | 'text' | 'json';
    /**
        default: 'snow'
     */
    theme?: 'snow' | 'bubble';
    readOnly?: boolean;
    toolbar?: QuillToolbarDefaultType | IQuillToolbarConfiguration;
    /**
     *wird nur benötigt, falls standard modules/toolbar nicht ausreicht
     */
    modules?: QuillModules;
}
declare const DIALOG_FIELD_NULLVALUE = "$NULL";
interface IDialogConfiguration<DTO = any> {
    fieldsOrCategoriesOfFields: DialogField<DTO>[] | DialogFieldCategory<DTO>[];
    title: string;
    enterKeyAsTabKey?: boolean;
    categoriesAsTabs?: boolean;
    size?: DialogSize;
    inputSize?: DialogInputSize;
    hideOkButton?: boolean;
    hideCancelButton?: boolean;
}
type DialogSize = 'small' | 'medium' | 'large';
type DialogInputSize = 'small' | 'medium' | 'large';
declare class GenericEditDialogResult<DATATYPE, MODETYPE> {
    key: string;
    dto: DATATYPE;
    mode: MODETYPE;
    submitResult: string;
}

declare abstract class GenericEditDialogBaseComponent<T> {
    protected logger: LoggerService;
    private differs;
    constructor(logger: LoggerService, differs: KeyValueDiffers);
    private sharedConfig;
    inputSizeDefault: DialogInputSize;
    categoriesAsTabs: boolean;
    onHidden: EventEmitter<void>;
    onCancel: EventEmitter<void>;
    onSubmit: EventEmitter<T>;
    onBeforeSubmit: EventEmitter<T>;
    onChangeDetected: EventEmitter<void>;
    protected differ: KeyValueDiffer<any, any>;
    protected subscriptions: Array<Subscription>;
    protected dtoItem: T;
    editItem: any;
    mode: any;
    errorText: string;
    dynamicLists?: DialogDynamicList[];
    submitResult: 'CANCEL' | 'OK' | string;
    protected onInit(): void;
    protected doCheck(): void;
    protected onDestroy(): void;
    hide(): void;
    private _inputSizeClass;
    get inputSizeClass(): string;
    set inputSizeClass(value: 'input-sm' | 'input-lg' | string);
    private _inputSize;
    get inputSize(): DialogInputSize;
    set inputSize(newSize: DialogInputSize);
    private getInputSizeClassForInputSize;
    private readonly dirty;
    readonly isDirty: i0.Signal<boolean>;
    resetDirty(): void;
    setDirty(): void;
    abstract isShown(): boolean;
    protected initData(dto?: T, mode?: any, //user-defined 'mode' without any logic in dialog. can e.g. be used to store meta-info like "INSERT|EDIT|DUPLICATE" in multi-role dialogs
    dynamicLists?: DialogDynamicList[]): void;
    protected resetData(): void;
    cancelDialog(): void;
    /**
     * Abschluss der Bearbeitung:
     * Konvertiert die Form-Eingabewerte in den korrekten Typ soweit erforderlich (z.B. string nach number).
     * Kopiert die Form-Eingabewerte in das Datenobjekt zurück.
     * Löst Submit Events aus
     *
     * @param submitResult
     */
    protected submitDialog(submitResult?: 'OK' | string): void;
    get isSubmitDisabled(): boolean;
    showErrors(errors: string[]): void;
    handleKeyboardEvent(event: KeyboardEvent): void;
    enterKeyAsTabKey: boolean;
    configureDialogFields(fieldsOrCategoriesOfFields: DialogField<T>[] | DialogFieldCategory<T>[]): void;
    get getAllDialogFields(): DialogField<T>[];
    protected getDialogField(fieldname: string): DialogField<T>;
    categories: DialogFieldCategory[];
    get visibleCategories(): DialogFieldCategory[];
    protected copyToEditItem(dto: T): void;
    private convertToIsoDate;
    protected numberToStringEditItem(field: DialogField<T>): void;
    protected stringToNumberEditItem(field: DialogField<T>): any;
    protected getValueOfDtoItem(fieldname: string): any;
    protected initNewEditItem(): void;
    protected prepareItem(): void;
    private convertEditItemValuesToCorrectTypes;
    protected stringToNullOrBool(value: any): boolean;
    private writeAllEditItemFieldToDtoItemFields;
    private writeEditItemFieldToDtoItemField;
    private fieldIsEmpty;
    private prepareDialogFields;
    private getControlType;
    private passwordConfirmInvalid;
    hasLookups(fieldname: string | DialogField<T>): boolean;
    getGroupableLookups(field: string | DialogField<T>): SelectItemGroup[];
    getLookups(fieldname: string | DialogField<T>): Array<SelectItem | SelectColor>;
    private lookupTypeCheck;
    private mapGroupedLookups;
    private isGroupedSelectItem;
    doOnChange(keyValueChange: KeyValueChangeRecord<string, any>): void;
    getSelectItem(fieldname: string): SelectItem;
    setCatActive(activeCat: DialogFieldCategory): void;
    private setFirstCatActive;
    private getDynamicLookupItems;
    getDynamicDatasource(field: DialogField<T>): DatasourceComponent;
    private getDynamicList;
    onButtonClicked(btn: DialogFieldButton, editItem: any): void;
    doOnDropdownGridShown(fieldname: string): void;
    private prepareGrid;
    private datasourceSubscriptions;
    bindGridSelectionToEditItem(): void;
    private unSubscribeDatasources;
    private hasDatePicker;
    private useBrowserDateInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericEditDialogBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GenericEditDialogBaseComponent<any>, never, never, { "inputSizeDefault": { "alias": "inputSizeDefault"; "required": false; }; "categoriesAsTabs": { "alias": "categoriesAsTabs"; "required": false; }; }, { "onHidden": "onHidden"; "onCancel": "onCancel"; "onSubmit": "onSubmit"; "onBeforeSubmit": "onBeforeSubmit"; "onChangeDetected": "onChangeDetected"; }, never, never, true, never>;
}

declare class GenericEditDialogService {
    private loggerService;
    constructor(loggerService: LoggerService);
    private notify;
    raiseNotify(data: any): void;
    private notifySubscriptions;
    subscribeOnNotify(next: (value: any) => void): void;
    unsubscribeNotifies(): void;
    private registeredConfigurations;
    private dialogComponent;
    setDialogComponent(dialogComponent: GenericEditDialogComponent<any>): void;
    registerDialogConfiguration(key: string, dialogConfiguration: IDialogConfiguration): any;
    registerDialogConfiguration(key: string, fieldsOrCategoriesOfFields: DialogField[] | DialogFieldCategory[], title?: string, categoriesAsTabs?: boolean): any;
    private getDialogConfiguration;
    show(configuration: IDialogConfiguration, dto?: any, mode?: any, lookups?: DialogDynamicList[]): Observable<GenericEditDialogResult<any, any>>;
    show<DATATYPE>(configuration: IDialogConfiguration, dto?: DATATYPE, mode?: any, lookups?: DialogDynamicList[]): Observable<GenericEditDialogResult<DATATYPE, any>>;
    show<DATATYPE, MODETYPE>(configuration: IDialogConfiguration, dto?: DATATYPE, mode?: MODETYPE, lookups?: DialogDynamicList[]): Observable<GenericEditDialogResult<DATATYPE, MODETYPE>>;
    show(key: string, dto?: any, mode?: any, lookups?: DialogDynamicList[]): Observable<GenericEditDialogResult<any, any>>;
    show<DATATYPE>(key: string, dto?: DATATYPE, mode?: any, lookups?: DialogDynamicList[]): Observable<GenericEditDialogResult<DATATYPE, any>>;
    show<DATATYPE, MODETYPE>(key: string, dto?: DATATYPE, mode?: MODETYPE, lookups?: DialogDynamicList[]): Observable<GenericEditDialogResult<DATATYPE, MODETYPE>>;
    private hiddenSubscription;
    private cancelSubscription;
    showConfig<DATATYPE>(configuration: IDialogConfiguration, dto?: DATATYPE, lookups?: DialogDynamicList[], mode?: any, key?: string): Observable<GenericEditDialogResult<DATATYPE, any>>;
    onCancel: Subject<void>;
    onHidden: Subject<void>;
    hide(): void;
    showErrors(errors: string[]): void;
    focus(fieldname: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericEditDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenericEditDialogService>;
}

declare abstract class SwtGenericEditDialogComponentBase<T = any> {
    component: GenericEditDialogComponent<T>;
    dialog: ModalDirective;
    dialogInitDirective: DialogInitDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericEditDialogComponentBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SwtGenericEditDialogComponentBase<any>, never, never, { "component": { "alias": "component"; "required": false; }; }, {}, never, never, true, never>;
}
declare class SwtGenericEditDialogInspiniaComponent extends SwtGenericEditDialogComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericEditDialogInspiniaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtGenericEditDialogInspiniaComponent, "swt-generic-edit-dialog-inspinia", never, {}, {}, never, never, false, never>;
}
declare class SwtGenericEditDialogSneatComponent extends SwtGenericEditDialogComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericEditDialogSneatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtGenericEditDialogSneatComponent, "swt-generic-edit-dialog-sneat", never, {}, {}, never, never, false, never>;
}

declare class GenericEditDialogComponent<T> extends GenericEditDialogBaseComponent<T> implements DoCheck, OnDestroy, OnInit {
    private genericEditDialogService;
    private destroyRef;
    constructor(logger: LoggerService, genericEditDialogService: GenericEditDialogService, differs: KeyValueDiffers, sharedConfig: SharedConfigService, destroyRef: DestroyRef);
    template: QueryList<SwtGenericEditDialogComponentBase>;
    get dialog(): ModalDirective;
    private get dialogInitDirective();
    modalTitle: string;
    titleSingular: string;
    dialogId: string;
    hideOkButton: boolean;
    hideCancelButton: boolean;
    disableAnimation: boolean;
    swtDropdownContainerContainer: string;
    /** Verfolgt ob der Dialog initialisiert wurde, um das Rendern versteckter Dialoge im DOM zu vermeiden (WAVE Barrierefreiheit) */
    isDialogOpen: i0.WritableSignal<boolean>;
    private onHiddenSubscription;
    /** set this true, if this dialog component should be used as the "global generic dialog" */
    set serviceDialog(value: boolean);
    /** used internal */
    isShown(): boolean;
    ngOnInit(): void;
    /** fix weil modal-open nicht herausgenommen wird wenn ein 2ter Dialog geoeffnet wird */
    private closeModalFix;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    /**
     * Fill Data and Show Dialog
     *
     * @param dto
     * @param mode user-defined 'mode' without any logic in dialog. can e.g. be used to store meta-info like "INSERT|EDIT|DUPLICATE" in multi-role dialogs
     * @param dynamicLists dynamic lookups (in contrary to static) which are loaded before dialog.show. they are refernced by a lookupKey in the configuration (lookups of type string)
     */
    show(dto?: T, mode?: any, dynamicLists?: DialogDynamicList[]): void;
    /**
     * Re-Open the Dialog with errors shown
     *
     * @param errors
     */
    showErrors(errors: string[]): void;
    submitDialog(submitResult?: 'OK' | string): void;
    hide(): void;
    cancelDialog(): void;
    get customFormButtonsBefore(): Array<DialogFieldButton>;
    get customFormButtonsAfter(): Array<DialogFieldButton>;
    private getCustomButtons;
    private _size;
    sizeClass: string;
    get size(): DialogSize;
    set size(newSize: DialogSize);
    private getSizeClass;
    focus(fieldname: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericEditDialogComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenericEditDialogComponent<any>, "swt-generic-edit-dialog", never, { "titleSingular": { "alias": "titleSingular"; "required": false; }; "dialogId": { "alias": "id"; "required": false; }; "serviceDialog": { "alias": "serviceDialog"; "required": false; }; }, {}, never, never, false, never>;
}

declare class GenericEditDialogInlineComponent<T> extends GenericEditDialogBaseComponent<T> implements DoCheck, OnDestroy, OnInit {
    constructor(logger: LoggerService, differs: KeyValueDiffers);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngDoCheck(): void;
    /**
    Bestimmt in welchem container der bs-dropdown-container gerendert wird. Default ist 'body'.
 */
    swtDropdownContainerContainer: string;
    /**
     * Konfiguriert den Aufbau des Formulars
     *
     * @param fieldsOrCategoriesOfFields
     */
    configureDialogFields(fieldsOrCategoriesOfFields: DialogField[] | DialogFieldCategory[]): void;
    /**
     * Übergibt die Bearbeitungsdaten
     * Wenn nicht aufgerufen, dann funktioniert die Change-Detection nicht!
     *
     * @param dto
     * @param dynamicLists
     */
    initData(dto?: T, dynamicLists?: DialogDynamicList[]): void;
    /**
     * Abschluss der Bearbeitung.
     * Kopiert die Form-Eingabewerte in das Datenobjekt zurück und liefert dieses als Ergebnis.
     */
    submitEdit(): T;
    cancelEdit(): void;
    /**
     * wird intern benutzt
     * */
    isShown(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericEditDialogInlineComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenericEditDialogInlineComponent<any>, "swt-generic-edit-dialog-inline", never, { "swtDropdownContainerContainer": { "alias": "swtDropdownContainerContainer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SwtGridLoadingDirective {
    private readonly grid;
    constructor();
    /** Wenn `true`, wird der `loading-indicator` angezeigt */
    readonly loading: i0.InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGridLoadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SwtGridLoadingDirective, "swt-grid[loading]", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

interface ListEditorWebApiService<T> {
    getList(): Promise<T[]>;
    update(updateItem: T): Promise<void>;
    insert(updateItem: T): Promise<any>;
    delete(id: any): Promise<void>;
}

type FieldName<T> = Extract<keyof T, string>;
declare class ListEditorComponent<ListItem = any> {
    private readonly destroyRef;
    private readonly logger;
    private readonly messageBoxService;
    private readonly i18n;
    private readonly editDialog;
    listItems: Array<ListItem>;
    idFieldname: FieldName<ListItem>;
    titleSingular: string;
    titlePlural: string;
    small: boolean;
    gridButtonColumn: GridColumn;
    explicitStoreKey?: string;
    onEdit: EventEmitter<ListItem>;
    listDatasource: DatasourceComponent;
    listGrid: GridComponent;
    private dialogConfig;
    set columns(allColumns: ListColumn<ListItem>[]);
    private _webApiService;
    set webApiService(value: ListEditorWebApiService<ListItem>);
    get storeKey(): string;
    refresh(focusId?: number): Promise<void>;
    private getListItemId;
    add(): void;
    gridButtonClicked(event: GridColumnButtonEvent): void;
    private delete;
    private deleteItem;
    private edit;
    private updateItem;
    private insertItem;
    focus(listItem: ListItem): void;
    isSelected(listItem: ListItem): boolean;
    private setEditableColumns;
    private setVisibleColumns;
    private listColumnToGridColumn;
    /** Das Grid unsterstützt nicht die Implementation eines lookupsKey */
    private isValidLookup;
    private fieldTypeToGridColumnType;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListEditorComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListEditorComponent<any>, "swt-list-editor", never, { "idFieldname": { "alias": "idFieldname"; "required": false; }; "titleSingular": { "alias": "titleSingular"; "required": false; }; "titlePlural": { "alias": "titlePlural"; "required": false; }; "small": { "alias": "small"; "required": false; }; "gridButtonColumn": { "alias": "gridButtonColumn"; "required": false; }; "explicitStoreKey": { "alias": "store-key"; "required": false; }; }, { "onEdit": "onEdit"; }, never, ["[custom-buttons]", "[grid-detail]"], false, never>;
}
type ListColumn<T = any> = DialogField<T> & Omit<GridColumn<T>, 'type' | 'lookups'> & ListColumnCustomFields;
declare class ListColumnCustomFields {
    hiddenInList?: boolean;
    hiddenInDialog?: boolean;
}

declare class ColHideDirective implements OnInit, OnDestroy {
    constructor(el: ElementRef);
    private readonly colVisibilityService;
    private readonly sharedConfig;
    private readonly hiddenClass;
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    set dsColHideName(name: string);
    hiddenByDefault: boolean;
    private columnElement;
    private colHideName;
    refreshColumnVisibility(): void;
    private setColumnHidden;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColHideDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColHideDirective, "[col-hide]", never, { "dsColHideName": { "alias": "col-hide"; "required": false; }; "hiddenByDefault": { "alias": "hidden-by-default"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DisableClickDirective implements OnInit, OnDestroy {
    private readonly el;
    constructor(el: ElementRef<HTMLElement>);
    private subscription;
    private _disableClick;
    set disableClick(value: boolean);
    private setDisabled;
    private removeDisabled;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DisableClickDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DisableClickDirective, "[disable-click]", never, { "disableClick": { "alias": "disable-click"; "required": false; }; }, {}, never, never, false, never>;
}

declare abstract class SwtGenericEditDialogFormComponentBase {
    component: GenericEditDialogFormComponent;
    dialogForm: NgForm;
    protected fieldValidate(field: DialogField<unknown>, fieldValue?: unknown, fieldValue2?: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericEditDialogFormComponentBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SwtGenericEditDialogFormComponentBase, never, never, { "component": { "alias": "component"; "required": false; }; }, {}, never, never, true, never>;
}
declare class SwtGenericEditDialogFormInspiniaComponent extends SwtGenericEditDialogFormComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericEditDialogFormInspiniaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtGenericEditDialogFormInspiniaComponent, "swt-generic-edit-dialog-form-inspinia", never, {}, {}, never, never, false, never>;
}
declare class SwtGenericEditDialogFormSneatComponent extends SwtGenericEditDialogFormComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericEditDialogFormSneatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtGenericEditDialogFormSneatComponent, "swt-generic-edit-dialog-form-sneat", never, {}, {}, never, never, false, never>;
}

declare class GenericEditDialogFormComponent implements OnInit, OnDestroy, AfterViewInit {
    private logger;
    changeDetectorRef: ChangeDetectorRef;
    private readonly locale;
    private readonly currencyCode;
    constructor(logger: LoggerService, changeDetectorRef: ChangeDetectorRef, locale: string, currencyCode: string);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    small: boolean;
    master: GenericEditDialogBaseComponent<any>;
    cat: DialogFieldCategory;
    editItem: any;
    dynamicLookups: DialogDynamicList[];
    inputClass: string;
    private subscriptions;
    template: QueryList<SwtGenericEditDialogFormComponentBase>;
    get dialogForm(): NgForm;
    swtDropdownContainerContainer: string;
    onDropdownGridShown: EventEmitter<string>;
    passwordConfirmInvalid(field: DialogField): boolean;
    fieldVisible(field: DialogField): boolean;
    getLookups(field: DialogField): Array<SelectItem | SelectColor>;
    getGroupableLookups(field: DialogField): SelectItemGroup[];
    /**
     * Used for trackBy in NgFor.
     * Prevents the unnecessary Destroy/Create of the Elements, what breaks ChangeDetection in Firefox
     */
    idenitifyGroupableLookupsChanged(index: any, item: SelectItemGroup): any;
    private ngSelectOptionsDictionary;
    getLookupsWithLabel(field: DialogField): Array<NgOption>;
    hasLookups(field: DialogField): boolean;
    dropDownClearClicked(fieldname: string): void;
    getDynamicDatasource(field: DialogField): DatasourceComponent;
    getDisplayValue(field: DialogField): string[];
    getDisplayValueOrDefault(field: DialogField, defaultValue: string): string[];
    refreshDialog(): void;
    formValueChanged: EventEmitter<GenericEditDialogFormComponent>;
    onFormValueChanged(data?: any): void;
    onSelectChanged(fieldname: string): void;
    private clearDependentSelect;
    formErrors: {};
    formValidate(data?: any): void;
    fieldValidate(field: DialogField<unknown>, fieldValue?: unknown, fieldValue2?: unknown): void;
    formatMoneyText(field: DialogField): string;
    private setFormErrors;
    private getErrorMessage;
    containsFormButtons(field: DialogField): boolean;
    formButtons(field: DialogField): DialogFieldButton[];
    onButtonClicked(btn: DialogFieldButton, editItem: any): void;
    doOnDropdownGridShown(fieldname: string): void;
    /**
     * Fokussiert das Dropdown-Grid-Komponente.
     *
     * Diese Methode prüft, ob die übergebene Grid-Komponente existiert und eine focusGrid-Methode besitzt.
     * Falls ja, wird die Fokussierung über requestAnimationFrame asynchron ausgeführt, um eine saubere
     * Ausführung im nächsten Browser-Render-Zyklus zu gewährleisten.
     *
     * @param gridComponent - Die Grid-Komponente, die fokussiert werden soll
     * @returns void
     */
    focusDropdownGrid(gridComponent: GridComponent): void;
    /**
     * Behandelt das FocusOut-Event des Dropdown-Grids.
     *
     * Schließt das Dropdown, wenn der Fokus den gesamten Dropdown-Grid-Container verlässt.
     * Prüft, ob das neue Fokus-Ziel (relatedTarget) innerhalb des Containers liegt.
     * Falls nicht, wird das Dropdown geschlossen und der Fokus zurück zum Dropdown-Container gesetzt,
     * damit die Tab-Reihenfolge korrekt fortgesetzt wird.
     *
     * @param event - Das FocusEvent
     * @param dropdownContainer - Die Dropdown-Container-Komponente
     * @returns void
     */
    onDropdownGridFocusOut(event: FocusEvent, dropdownContainer: any): void;
    clickSpinnerUp(eventData: any, field: DialogField): void;
    clickSpinnerDown(eventData: any, field: DialogField): void;
    private getHasDatePicker;
    private readonly hasDatePicker;
    useBrowserDateInput(field: DialogField): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericEditDialogFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenericEditDialogFormComponent, "swt-generic-edit-dialog-form", never, { "master": { "alias": "master"; "required": false; }; "cat": { "alias": "cat"; "required": false; }; "editItem": { "alias": "editItem"; "required": false; }; "dynamicLookups": { "alias": "dynamicLookups"; "required": false; }; "inputClass": { "alias": "inputClass"; "required": false; }; "swtDropdownContainerContainer": { "alias": "swtDropdownContainerContainer"; "required": false; }; }, { "onDropdownGridShown": "onDropdownGridShown"; "formValueChanged": "formValueChanged"; }, never, never, false, never>;
}

declare class SwtGenericModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtGenericModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SwtGenericModule, [typeof GridComponent, typeof GridCellSpanComponent, typeof GridCellSpanRouterLinkComponent, typeof ListEditorComponent, typeof MultiSelectFilterComponent, typeof SwtGridLoadingDirective, typeof DisableClickDirective, typeof ColHideDirective, typeof ColSelectDialogComponent, typeof ColSelectDialogInspiniaComponent, typeof ColSelectDialogSneatComponent, typeof GenericEditDialogComponent, typeof GenericEditDialogFormComponent, typeof GenericEditDialogInlineComponent, typeof SwtGenericEditDialogInspiniaComponent, typeof SwtGenericEditDialogFormInspiniaComponent, typeof SwtGenericEditDialogSneatComponent, typeof SwtGenericEditDialogFormSneatComponent], [typeof i15.CommonModule, typeof i16.NgSelectModule, typeof i17.FormsModule, typeof i18.RouterModule, typeof i19.DialogsModule, typeof i20.BsDropdownModule, typeof i21.TypeaheadModule, typeof i22.PopoverModule, typeof i23.TimepickerModule, typeof i23.TimepickerModule, typeof i24.SwtControlsModule, typeof i25.DatasourceModule, typeof i26.DragulaModule, typeof i27.NgxMaskDirective, typeof i27.NgxMaskPipe, typeof i28.NoDblClickModule, typeof i29.KeyboardShortcutsModule, typeof i30.NoEditButtonModule, typeof i31.NgScrollbarModule, typeof i32.SwitchTemplateModule, typeof i33.ButtonsModule, typeof i34.LayoutModule, typeof i35.TypedTemplateDirective, typeof i36.NgSelectAriaLabelDirective], [typeof GridComponent, typeof MultiSelectFilterComponent, typeof ListEditorComponent, typeof ColHideDirective, typeof ColSelectDialogComponent, typeof i23.TimepickerModule, typeof GenericEditDialogComponent, typeof GenericEditDialogInlineComponent, typeof SwtGridLoadingDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SwtGenericModule>;
}

export { ColHideDirective, ColSelectDialogComponent, DIALOG_FIELD_NULLVALUE, DialogDynamicList, DialogField, DialogFieldButton, DialogFieldCategory, DialogGridConfiguration, GenericEditDialogComponent, GenericEditDialogFormComponent, GenericEditDialogInlineComponent, GenericEditDialogResult, GenericEditDialogService, GridCellSpanComponent, GridCellSpanRouterLinkComponent, GridColumn, GridColumnButton, GridColumnButtonEvent, GridColumnSpan, GridComponent, GridConfiguration, GridDropEvent, GridDropRemoveEvent, GridTitleSpan, Html5DragDropEvent, ListEditorComponent, MultiSelectFilterComponent, RichTextConfiguration, RowClickEvent, SpanClickEvent, SwtGenericModule, SwtGridLoadingDirective, TextMaskConfig };
export type { AggregateFunctionGridConfig, ControlType, DialogInputSize, DialogSize, FieldType, GridColumnType, GridLookup, GridSpanVariant, HeaderTitleGroups, IDialogConfiguration, IHeaderTitleGroup, IStackedProgressBar, ListColumn, ListEditorWebApiService, Lookups, lookupsKey };