import { Maybe, ObjectForExtending, Prettify } from './utils.type';
import { MergedCellsAlign } from './merged-cells.type';
import { ColumnsGroupingConfig } from './columns-grouping.type';
import { ColumnConfig, EditingCellInfo, SortColumn } from './column-config.type';
import { DomMetadata } from './additional.type';
import { MassActionButtonProps } from '../widgets/mass-actions/types';
import { FeatureItem, PinningMenuConfig, SidebarTab } from '../widgets/control-block/types';
import { ControlBlockButtonProps } from '../widgets/control-block/control-block-button.types';
import { CellReadOnlyEditorGlideInstanceStaticProps, CellsSelectionMode, HighlightActiveType, HoverEffectsConfig, TableGlideCustomProps, TableGlideInstanceProps, TableInfoWithRow } from '../TableGlideInstance/type';
import { SubRows } from '../feature-tree/types';
import { FlattenedRowsArrAndMap, SelectingRowConfig } from '../feature-select-row/types';
import { SearchingProps } from '../feature-searching/types';
import { RowsGrouping } from '../feature-rows-grouping/types';
import { PaginationProps } from '../feature-pagination/types';
import { TableNotificationsConfig } from '../feature-notifications';
import { KeyTextConfig } from '../feature-key-text/types';
import { FullScreen } from '../feature-full-screen/types';
import { TableCanvasEmptyStateConfig, TableCanvasErrorStateConfig } from '../feature-content-state/types';
import { ColumnsControlConfig } from '../feature-column-control/types';
import { CellTransferConfig, FillMeta, RowsChangeType } from '../feature-cell-transfer/types';
import { TableDropdownConfigProps } from '../components/TableDropdown/types';
import { CSSObject } from 'styled-components';
import { CSSProperties, ReactNode } from 'react';
import { SIZE } from '..';
import { MassActionsSize } from '../../MassActions';
import { Group, Item, ItemOrGroup } from '../../ListOfFilters';
import { GridSelection } from '@glideappsfinal/glide-data-grid';

export type { ColumnsGroupingConfig, HeaderAlignment, } from './columns-grouping.type';
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 extends ObjectForExtending, SR = unknown> {
    indexes: number[];
    column: ColumnConfig<R, SR>;
    rows: {
        before: R;
        after: R;
    }[];
    type: RowsChangeType;
    fillMeta?: FillMeta;
    fillResult?: string[][];
}
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;
}, rowIndex: number) => number;
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;
    titleText?: string;
    titleRender?: React.ReactNode;
};
export type { FlattenedRowsArrAndMap };
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';
export 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;
        showInSidebar?: boolean;
        iconTooltipText?: undefined;
    } | {
        id: 'tableSettings';
        label?: string;
        title?: string;
        domMetadata?: DomMetadata;
        customGeneralSettingsSlot?: React.ReactNode;
        titleRightSlot?: React.ReactNode;
        showInSidebar?: boolean;
        iconTooltipText?: string;
    }>;
};
export declare function activeViewIs<T extends 'cards' | 'rows'>(checkType: T, viewState: 'cards' | 'rows', view: View): view is ViewMods[T];
export type ControlBlockSize = 'm' | 's' | 'xs';
export type ControlBlockConfig = {
    show?: boolean;
    size?: ControlBlockSize;
    leftSideInner?: ControlBlockButtonProps[];
    rightSideInner?: ControlBlockButtonProps[];
    customFeatures?: FeatureItem[];
    pinningMenu?: PinningMenuConfig;
    leftSideDropdownProps?: TableDropdownConfigProps;
    rightSideDropdownProps?: TableDropdownConfigProps;
    enableAdaptiveCompress?: boolean;
    massActionPanel?: {
        buttons: MassActionButtonProps[];
        collapsedDropdownProps?: TableDropdownConfigProps;
        bottom?: number;
        show?: boolean;
        size?: MassActionsSize;
    };
};
export type EditingButtonProps = Omit<Partial<ControlBlockButtonProps>, 'onClick' | 'size' | 'dropdown' | 'isTargetAction' | 'skipRightDivider' | 'tooltipText'>;
export type EditingConfig<RowType extends ObjectForExtending, RowIdType, SummaryRowType> = {
    onRowsChange: Maybe<(rows: RowType[], data: RowsChangeData<RowType, SummaryRowType>) => void>;
    subRowsKey?: string;
    deepCloneRows?: boolean;
    rowKeyGetter: (row: RowType) => RowIdType;
    rowEditable?: (row: RowType) => boolean;
    defaultEnabled?: boolean;
    enabled?: boolean | [boolean, React.Dispatch<React.SetStateAction<boolean>>];
    showButtons?: boolean;
    onEnableEditing?: (enableEditorMode: () => void) => void;
    onSave?: (disableEditorMode: () => void) => void;
    onCancel?: (disableEditorMode: () => void) => void;
    buttons?: {
        save?: EditingButtonProps;
        cancel?: EditingButtonProps;
        edit?: EditingButtonProps;
    };
    editModeLeftSlot?: React.ReactNode;
    domMetadata?: {
        enableButton?: DomMetadata;
        saveButton?: DomMetadata;
        cancelButton?: DomMetadata;
    };
};
export type SummaryRowsConfig = {
    showDefault: boolean;
    showInControl: boolean;
} & {
    domMetadata?: DomMetadata;
};
export type TableConfigTooltip = {
    enabled?: boolean;
    mouseEnterDelay?: number;
    mouseLeaveDelay?: number;
    minWidth?: number | string;
    maxWidth?: number | string;
};
export type InfinityScrollConfig<RowType extends ObjectForExtending> = {
    onTrigger: (rows: RowType[]) => Promise<void> | void;
    isLoading: boolean;
    hasMore?: boolean;
    rowThreshold?: number;
};
export type { TableCanvasEmptyStateConfig, TableCanvasErrorStateConfig };
export type CellsSelectionConfig = {
    mode?: CellsSelectionMode;
    enableColumnSelection?: boolean;
    enableRowSelection?: boolean;
    enableSelectAll?: boolean;
    state?: [GridSelection, React.Dispatch<React.SetStateAction<GridSelection>>];
};
export type MergedCellsRegion = {
    rowKeys: Array<string | number>;
    colKeys: string[];
    mergedCellsAlign?: MergedCellsAlign;
};
export type CellBorderVisibility = {
    top?: boolean;
    right?: boolean;
    bottom?: boolean;
    left?: boolean;
};
export type BordersConfig<RowType = ObjectForExtending> = {
    vertical?: boolean;
    horizontal?: boolean;
    getVerticalBorder?: (params: {
        columnKey: string;
        columnIndex: number;
    }) => boolean | undefined;
    getHorizontalBorder?: (params: {
        row: RowType;
        rowIndex: number;
        treeLvl: number;
    }) => boolean | undefined;
    getCellBorder?: (params: {
        col: number;
        columnKey: string | undefined;
        row: RowType;
        rowIndex: number;
        treeLvl: number;
    }) => CellBorderVisibility | undefined;
};
export type TableConfig<RowType extends ObjectForExtending, SummaryRowType, RowIdType extends string | number, FilterStateType extends ObjectForExtending> = {
    columnsGrouping?: ColumnsGroupingConfig;
    highlightActiveType?: HighlightActiveType;
    cellsSelection?: CellsSelectionConfig;
    highlightActiveRow?: {
        state?: [
            number | undefined,
            React.Dispatch<React.SetStateAction<number | undefined>>
        ];
        onChange?: (params: {
            index: number | undefined;
            row: RowType | undefined;
        }) => void;
    };
    hoverEffects?: HoverEffectsConfig;
    enableLowDprHairline?: boolean;
    borders?: BordersConfig<RowType>;
    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>>>
        ];
        rowKeyGetter: (row: RowType) => RowIdType;
    } & Prettify<SelectingRowConfig<RowType, RowIdType>> & {
        controlBlock?: {
            domMetadata?: DomMetadata;
        };
        sidebar?: {
            domMetadata?: DomMetadata;
        };
    };
    editing?: EditingConfig<RowType, RowIdType, SummaryRowType>;
    cellTransfer?: CellTransferConfig;
    mergeCells?: {
        mergeByCellValues?: Array<string | {
            colKey: string;
            value: (row: RowType) => unknown;
        }>;
        mergedCellsRegions?: MergedCellsRegion[];
        rowKeyGetter?: (row: RowType) => string | number;
        mergedCellsAlign?: MergedCellsAlign;
    };
    notifications?: TableNotificationsConfig;
    subRows?: SubRows<RowType, RowIdType>;
    rowMarkers?: RowMarkersTableConfig<RowType>;
    rowsGrouping?: RowsGrouping<RowType, SummaryRowType>;
    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;
    unstickyHeader?: boolean;
    tooltip?: TableConfigTooltip;
    infinityScroll?: InfinityScrollConfig<RowType>;
    isLoading?: boolean | {
        boolean: boolean;
        skeletonRowsCount: number;
    };
    loadingOverlay?: {
        active?: boolean;
        spinner?: ReactNode;
        title?: string;
        subtitle?: string;
        showSubtitleDelay?: number;
    };
    emptyState?: TableCanvasEmptyStateConfig;
    errorState?: TableCanvasErrorStateConfig;
    columnsControl?: ColumnsControlConfig;
    fullScreenEnabled?: FullScreen;
    editorOverlayPortal?: 'inside';
    keyText?: boolean | KeyTextConfig;
    pagination?: PaginationProps;
    sidebarConfig?: SidebarConfig;
    searching?: SearchingProps;
    onHeaderContextMenu?: TableGlideInstanceProps<RowType, SummaryRowType>['onHeaderContextMenu'];
    onHeaderContextMenuDropdown?: TableGlideInstanceProps<RowType, SummaryRowType>['onHeaderContextMenuDropdown'];
    onCellContextMenuDropdown?: TableGlideInstanceProps<RowType, SummaryRowType>['onCellContextMenuDropdown'];
    onCellContextMenu?: TableGlideInstanceProps<RowType, SummaryRowType>['onCellContextMenu'];
    onCellClicked?: (cell: readonly [number, number], info: TableInfoWithRow<RowType, SummaryRowType>) => void;
} & GlideInstanceOmitted<RowType, SummaryRowType>;
type GlideInstanceOmitted<RowType extends ObjectForExtending, SummaryRowType> = Pick<Omit<TableGlideInstanceProps<RowType, SummaryRowType>, keyof TableGlideCustomProps<RowType, SummaryRowType> | 'CellReadOnlyEditor'>, 'className' | 'columnSelect' | 'minColumnWidth' | 'maxColumnWidth' | 'maxColumnAutoWidth' | 'onVisibleRegionChanged' | 'onCellClicked' | 'onHeaderClicked' | 'onItemHovered' | 'trapFocus' | 'onColumnResize'>;
export type CellReadOnlyEditorProps<RowType extends ObjectForExtending, SummaryRowType> = CellReadOnlyEditorGlideInstanceStaticProps & EditingCellInfo<RowType, SummaryRowType>;
export type RowMarkersTableConfig<RowType extends ObjectForExtending = ObjectForExtending> = {
    startIndex?: number;
    width?: number;
    size?: 'xs' | 's' | 'm';
    getRowMarker?: (args: {
        row: RowType;
        level: number;
        isSubRow: boolean;
        rowIndex: number;
        flatIndex: number;
        siblingIndex: number;
        siblingPath: number[];
        parentKey: string | number | null;
        rows: readonly RowType[];
    }) => string | number;
};