import { Maybe, ObjectForExtending, Prettify } from './utils.type';
import { DataGridPropsDefault } from './data-grid.type';
import { DomMetadata } from './additional.type';
import { FeatureItem, SidebarTab } from '../widgets/control-block/types';
import { ControlBlockButtonProps } from '../widgets/control-block/control-block-button.types';
import { SubRows } from '../feature-tree/types';
import { ChildrenInfo, RowCheckboxDisabled, RowGetStatesProps, RowGetStatesReturnType, RowShowCheckbox } from '../feature-select-row/types';
import { SELECTING_KEYS } from '../feature-select-row/constants';
import { SearchingProps } from '../feature-searching/types';
import { GroupRow, RowsGrouping } from '../feature-rows-grouping/types';
import { RowDetailConfig } from '../feature-row-detail/types';
import { PaginationProps } from '../feature-pagination/types';
import { KeyTextConfig } from '../feature-key-text/types';
import { FullScreen } from '../feature-full-screen/types';
import { CellContextMenuDropDownProps, HeaderContextMenuDropDownProps, HeaderContextMenuProps } from '../feature-context-menu';
import { ColumnsControlConfig } from '../feature-column-control/types';
import { TableDropdownConfigProps } from '../components/TableDropdown/types';
import { CSSObject } from 'styled-components';
import { CalculatedColumn, SortColumn } from 'react-data-grid';
import { ChangeEvent, CSSProperties, ReactNode } from 'react';
import { RowInstrumentsType, SIZE } from '..';
import { MassActionsButtonProps, MassActionsSize } from '../../MassActions/types';
import { Group, Item, ItemOrGroup } from '../../ListOfFilters';

export type HighlightActiveType = 'cell' | 'row' | 'disabled';
export type ViewMods = {
    rows: {
        type: 'rows';
        domMetadata?: DomMetadata;
    };
    cards: {
        type: 'cards';
        typeCardsRender: ReactNode;
        domMetadata?: DomMetadata;
    };
    bothTypes: {
        type: 'both-types';
        typeCardsRender: ReactNode;
        default?: 'cards' | 'rows';
        domMetadata?: DomMetadata;
    };
};
export interface RowsChangeData<R, SR = unknown> {
    indexes: number[];
    column: CalculatedColumn<R, SR>;
    rows: {
        before: R;
        after: R;
    }[];
}
export type ActiveViewModsType = Exclude<keyof ViewMods, 'bothTypes'>;
export type View = ViewMods['rows' | 'bothTypes' | 'cards'];
export type { ControlBlockButtonProps };
export type RowSize = {
    showInControl: boolean;
    default?: SIZE;
    available?: SIZE[];
    onRowSizeChange?: (size: SIZE) => void;
    domMetadata?: DomMetadata;
};
export type RowHeightFunc<RowType> = (row: RowType, currentRowSize: {
    rowSizeName: SIZE;
    rowSizeValue: number;
}) => number;
type SummaryCheckedFunc<RowType, ReturnType, AdditionalPropsObj extends ObjectForExtending | void = void, RowIdType extends string | number = string | number> = (props: {
    rows: RowType[];
    flattenedRows: (RowType & {
        level?: number;
        parent?: RowType | null;
    })[];
    selectedRowsIds: ReadonlySet<string | number>;
    rowKeyGetter: (row: RowType) => string | number;
    rowCheckboxDisabled: SelectingRowConfig<RowType, RowIdType>['rowCheckboxDisabled'];
    rowShowCheckbox: SelectingRowConfig<RowType, RowIdType>['rowShowCheckbox'];
    allRowsInLevels: (RowType & {
        level?: number;
        parent?: RowType | null;
    })[];
    getAllRowsInfo: () => ChildrenInfo<RowType, RowIdType>;
} & (AdditionalPropsObj extends ObjectForExtending ? AdditionalPropsObj : {})) => ReturnType;
export type TableCollapseConfig = {
    enableCollapse?: boolean;
    defaultCollapsed?: boolean;
    collapseText?: string;
    expandText?: string;
    onToggleCollapse?: (isCollapsed: boolean) => void;
    collapsedState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
    domMetadata?: DomMetadata;
    collapseButtonPlacement?: 'inside' | 'above';
    collapseButtonAboveRightSlot?: React.ReactNode;
};
export type FlattenedRowsArrAndMap<RowType, RowIdType> = {
    flattenedRows: (RowType & {
        [SELECTING_KEYS.level]?: number;
        [SELECTING_KEYS.parent]?: RowType | null;
    })[];
    flattenedRowsMap: Map<RowIdType, RowType & {
        [SELECTING_KEYS.level]?: number;
        [SELECTING_KEYS.parent]?: RowType | null;
    }>;
};
export type SelectingRowConfig<RowType, RowIdType extends string | number = string | number> = {
    rowKeyGetter: (row: RowType) => RowIdType;
    showDefault?: boolean;
    showState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
    showInControl?: boolean;
    selectingRules?: {
        levels?: number | 'all' | number[] | ((lvl: number) => boolean);
    };
    disableSummaryCheckboxInHeader?: boolean;
    hideSummaryCheckboxInHeader?: boolean;
    hideSummaryCheckbox?: boolean;
    summaryChecked?: {
        checked: boolean | SummaryCheckedFunc<RowType, boolean>;
        indeterminate: boolean | SummaryCheckedFunc<RowType, boolean, {
            checkedAll: boolean;
        }>;
        getCountOfChecked: SummaryCheckedFunc<RowType, number>;
        onChange: SummaryCheckedFunc<RowType, void, {
            checkedAll: boolean;
            clearButtonClicked?: boolean;
            setSelectedRowsIds: React.Dispatch<React.SetStateAction<ReadonlySet<string | number>>>;
        }>;
    };
    summaryCheckedUncontrolled?: {
        onChange: (event: ChangeEvent<HTMLInputElement>) => void;
    };
    rowShowCheckbox?: RowShowCheckbox<RowType>;
    rowCheckboxDisabled?: RowCheckboxDisabled<RowType>;
    rowGetStates?: (p: RowGetStatesProps<RowType, RowIdType>) => RowGetStatesReturnType<RowType, RowIdType> | null;
    groupedRow?: {
        getStates: (p: {
            checkedCalculated: boolean;
            indeterminateCalculated: boolean;
            row: GroupRow<RowType>;
            selectedRows: ReadonlySet<string | number>;
            selectedChildCount: number;
            childCount: number;
        }) => {
            checked?: boolean | null;
            indeterminate?: boolean | null;
            showCheckbox?: boolean | null;
            checkboxDisabled?: boolean | null;
        } | null;
        onChange?: (p: {
            row: GroupRow<RowType>;
            setSelectedRows: React.Dispatch<React.SetStateAction<ReadonlySet<string | number>>>;
            checked: boolean;
            indeterminate: boolean;
            checkboxDisabled: boolean;
            showCheckbox: boolean;
            defaultSetter: () => void;
        }) => void;
    };
};
export type FilteringConfig<T> = {
    state: [T, React.Dispatch<React.SetStateAction<T>>];
    clearedValue?: T;
    filtersInfo?: Record<keyof T, {
        label: string;
        clearedValue: T[keyof T];
    }>;
    manualFiltering?: boolean;
    sidebarConfig?: {
        order?: string[];
        items: Partial<Record<keyof T, {
            label: string;
            customRenderFn?: (filters: T, setFilters: React.Dispatch<React.SetStateAction<T>>) => React.ReactNode;
        }>>;
    };
    chipStyle?: (itemOrGroup: ItemOrGroup, item: Item | undefined) => CSSObject;
    renderGroupLabel?: (group: Group) => string;
    renderChipLabel?: (group: Group | null, item: Item) => string;
};
export type DefaultSidebarTabIds = 'columns' | 'tableSettings' | 'filtering';
type SidebarConfig = {
    enabled?: boolean;
    defaultOpen?: boolean;
    openState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
    defaultActiveTabId?: string;
    activeTabState?: [
        string | null,
        React.Dispatch<React.SetStateAction<string | null>>
    ];
    onActiveTabChange?: (tabId: string | null, tab?: SidebarTab) => void;
    customTabs?: Array<Omit<SidebarTab, 'id'> & {
        id: Exclude<string, DefaultSidebarTabIds>;
    }>;
    customTabsOrder?: Array<Exclude<string, DefaultSidebarTabIds>>;
    defaultTabs?: Array<{
        id: 'filtering' | 'columns';
        label?: string;
        title?: string;
        domMetadata?: DomMetadata;
        titleRightSlot?: React.ReactNode;
    } | {
        id: 'tableSettings';
        label?: string;
        title?: string;
        domMetadata?: DomMetadata;
        customGeneralSettingsSlot?: React.ReactNode;
        titleRightSlot?: React.ReactNode;
    }>;
};
export declare function activeViewIs<T extends 'cards' | 'rows'>(checkType: T, viewState: 'cards' | 'rows', view: View): view is ViewMods[T];
export type ControlBlockConfig = {
    show?: boolean;
    leftSideInner?: ControlBlockButtonProps[];
    rightSideInner?: ControlBlockButtonProps[];
    customFeatures?: FeatureItem[];
    leftSideDropdownProps?: TableDropdownConfigProps;
    rightSideDropdownProps?: TableDropdownConfigProps;
    enableAdaptiveCompress?: boolean;
    massActionPanel?: {
        buttons: MassActionsButtonProps[];
        collapsedDropdownProps?: TableDropdownConfigProps;
        bottom?: number;
        show?: boolean;
        size?: MassActionsSize;
    };
};
export type EditingConfig<RowType, RowIdType, SummaryRowType> = {
    onRowsChange: Maybe<(rows: RowType[], data: RowsChangeData<RowType, SummaryRowType>) => void>;
    subRowsKey?: string;
    rowKeyGetter: (row: RowType) => RowIdType;
    rowEditable?: (row: RowType) => boolean;
    defaultEnabled?: boolean;
    enabled?: boolean | [boolean, React.Dispatch<React.SetStateAction<boolean>>];
    showToggleEnabledButton?: boolean;
    onToggleEnableEditing?: (editingIsActive: boolean) => void;
    domMetadata?: DomMetadata;
};
export type SummaryRowsConfig = {
    showDefault: boolean;
    showInControl: boolean;
} & {
    domMetadata?: DomMetadata;
};
export type TableConfig<RowType extends ObjectForExtending, SummaryRowType, RowIdType extends string | number, FilterStateType extends ObjectForExtending> = {
    highlightActiveType?: HighlightActiveType;
    rowSize?: Prettify<RowSize>;
    rowHeight?: Maybe<number | RowHeightFunc<RowType>>;
    sorting?: {
        state: [
            readonly SortColumn[],
            React.Dispatch<React.SetStateAction<readonly SortColumn[]>>
        ];
        manualSorting?: boolean;
    };
    view?: View;
    filtering?: FilteringConfig<FilterStateType>;
    collapsing?: TableCollapseConfig;
    selecting?: {
        state: [
            ReadonlySet<RowIdType>,
            React.Dispatch<React.SetStateAction<ReadonlySet<RowIdType>>>
        ];
    } & Prettify<SelectingRowConfig<RowType, RowIdType>> & {
        controlBlock?: {
            domMetadata?: DomMetadata;
        };
        sidebar?: {
            domMetadata?: DomMetadata;
        };
    };
    editing?: EditingConfig<RowType, RowIdType, SummaryRowType>;
    subRows?: SubRows<RowType, RowIdType>;
    rowsGrouping?: RowsGrouping<RowType>;
    resizableColumn?: boolean;
    style?: Omit<CSSProperties, 'width' | 'height' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight'>;
    css?: string | CSSObject;
    summaryRows?: SummaryRowsConfig;
    controlBlock?: ControlBlockConfig;
    containerStyle?: CSSProperties | undefined;
    containerCss?: string | CSSObject | undefined;
    containerId?: string | undefined;
    infinityScroll?: {
        onTrigger: (rows: RowType[]) => Promise<void> | void;
        isLoading: boolean;
        hasMore?: boolean;
        scrollThreshold?: number;
    };
    isLoading?: boolean | {
        boolean: boolean;
        skeletonRowsCount: number;
    };
    loadingOverlay?: {
        active?: boolean;
        spinner?: ReactNode;
        title?: string;
        subtitle?: string;
        showSubtitleDelay?: number;
    };
    noRowsFallback?: boolean | {
        custom: ReactNode;
    };
    columnsControl?: ColumnsControlConfig;
    rowDetailPanel?: RowDetailConfig<RowType>;
    rowInstruments?: {
        getRowDropdownConfig: RowInstrumentsType<RowType>;
        defaultOpened?: boolean;
        showInControl?: boolean;
        openedState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
    };
    fullScreenEnabled?: FullScreen;
    keyText?: boolean | KeyTextConfig;
    pagination?: PaginationProps;
    sidebarConfig?: SidebarConfig;
    searching?: SearchingProps;
    onHeaderContextMenu?: HeaderContextMenuProps;
    onHeaderContextMenuDropDown?: HeaderContextMenuDropDownProps;
    onCellContextMenuDropDown?: CellContextMenuDropDownProps<RowType, SummaryRowType>;
} & Pick<DataGridPropsDefault<RowType, SummaryRowType, RowIdType>, 'summaryRowHeight' | 'onFill' | 'onCopy' | 'onPaste' | 'onCellClick' | 'onCellDoubleClick' | 'onCellContextMenu' | 'onCellKeyDown' | 'onSelectedCellChange' | 'onScroll' | 'onColumnResize' | 'onColumnsReorder' | 'enableVirtualization' | 'rowClass' | 'data-testid' | 'headerRowHeight'>;