import { Component, HTMLAttributes, MaybeRef, MaybeRefOrGetter, Ref, TdHTMLAttributes, ThHTMLAttributes, VNode, VNodeProps, WatchSource } from 'vue';
import { OnyxI18n } from '../../../i18n/index.js';
import { Nullable } from '../../../types/index.js';
import { Orderable, OrderableMapping } from '../../../utils/feature.js';
import { OnyxMenuItem } from '../../OnyxNavBar/modules/index.js';
import { OnyxTableSlots, TableColumnGroup } from '../../OnyxTable/types.js';
import { DataGridRendererCell, DataGridRendererColumn, DataGridRendererRow } from '../OnyxDataGridRenderer/types.js';
import { ColumnTypesFromFeatures, DataGridEntry, DataGridMetadata } from '../types.js';
import { BASE_FEATURE } from './base/base.js';
import { DataGridAction } from './dataGridActions/types.js';
/**
 * Function type for modifying the normalized column configuration.
 */
export type ModifyColumns<TEntry extends DataGridEntry> = OrderableMapping<InternalColumnConfig<TEntry>[]>;
export type HeaderCellProps<TOptions = unknown> = {
    label: string;
    typeOptions?: TOptions;
};
export type TypeRendererHeaderDef<TEntry extends DataGridEntry, TOptions = undefined> = Omit<DataGridRendererColumn<TEntry, HeaderCellProps<TOptions>>, "key" | "props">;
export type CellMetadata<TOptions = unknown> = {
    typeOptions?: TOptions;
    editable?: Nullable<boolean>;
};
export type TypeRendererCell<TEntry extends DataGridEntry, TOptions = undefined> = Omit<DataGridRendererCell<TEntry, CellMetadata<TOptions>>, "props">;
/**
 * Defines how a specific column type should be rendered.
 */
export type TypeRenderer<TEntry extends DataGridEntry, TOptions = undefined> = {
    header?: TypeRendererHeaderDef<TEntry, TOptions>;
    cell: TypeRendererCell<TEntry, TOptions>;
};
/**
 * Maps a "type" key to a column renderer.
 * `symbol` keys are intended for internal/helper columns.
 */
export type TypeRenderMap<TEntry extends DataGridEntry, TKey extends PropertyKey = PropertyKey> = Partial<Record<TKey, Readonly<TypeRenderer<TEntry, object>>>>;
/**
 * ColumnConfig as it can be defined by the user.
 */
export type ColumnConfig<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig = Record<string, never>, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown> = never> = keyof TEntry | PublicNormalizedColumnConfig<TEntry, TColumnGroup, TTypes | ColumnTypesFromFeatures<ReturnType<typeof BASE_FEATURE>>>;
export type DefaultSupportedTypes = keyof ReturnType<ReturnType<typeof BASE_FEATURE>>["typeRenderer"];
/**
 * Configuration for the column groupings.
 */
export type ColumnGroupConfig = Record<string, {
    label: string;
}>;
/**
 * Column config used internally and by the `modifyColumns` functions.
 */
export type InternalColumnConfig<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig = any> = Omit<PublicNormalizedColumnConfig<TEntry, TColumnGroup, never>, "label" | "type"> & {
    type: ColumnTypeNormalized<PropertyKey, unknown>;
    /**
     * Attributes that should be set on all `td` elements
     */
    tdAttributes?: TdHTMLAttributes;
    /**
     * Attributes that should be set on all `th` elements
     */
    thAttributes?: ThHTMLAttributes;
    /**
     * After normalization the label is always defined.
     */
    label: string;
};
export type ColumnTypeNormalized<TKey, TOptions> = {
    name: TKey;
    options?: TOptions;
};
export type ColumnConfigTypeOption<TKey, TOptions> = TKey | ColumnTypeNormalized<TKey, TOptions>;
/**
 * Normalized column config for public/external usage.
 */
export type PublicNormalizedColumnConfig<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>> = Pick<DataGridRendererColumn<TEntry>, "width" | "key"> & {
    /**
     * The `label` is displayed in the data grid as column header.
     * If not defined, the key is used instead.
     */
    label?: string;
    /**
     * The `type` of the column. It defines how the header and cells of a column is rendered.
     * If not defined the values are displayed as plain strings.
     */
    type?: TTypes;
    /**
     * Key of the ColumnGroup that this column should be visually grouped in.
     * The columns have to be defined in the correct order.
     * So columns that should be grouped together have to actually be defined after each other.
     *
     * The label for the column group can be configured via the `columnGroups` prop.
     */
    columnGroupKey?: keyof TColumnGroup;
};
/**
 * Context that is passed to a feature when it is set up by the `useDataGridFeatures` composable.
 */
export type DataGridFeatureContext = {
    /**
     * Ref for the `async` state of the `OnyxDataGrid`. If `true` data mutations should be skipped, if they are expected to be handled by a backend.
     */
    async: Readonly<Ref<boolean>>;
    /**
     * The `i18n` object, which can be used to access messages, formatters and the current locale.
     */
    i18n: OnyxI18n;
    /**
     * Whether the data grid should be shows as skeleton.
     */
    skeleton: Readonly<Ref<number | boolean>>;
};
/**
 * Complete Type for a single data grid feature.
 */
export type DataGridFeature<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = (ctx: DataGridFeatureContext) => DataGridFeatureDescription<TEntry, TTypeRenderer, TFeatureName>;
export type DataGridFeatureMutation<TEntry extends DataGridEntry> = {
    func: (state: Readonly<TEntry>[]) => Readonly<TEntry>[] | void;
} & Orderable;
/**
 * Object that describes the hooks and properties of a datagrid feature.
 */
export type DataGridFeatureDescription<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = {
    /**
     * Unique name and identifier of the datagrid feature
     */
    name: TFeatureName;
    /**
     * An array of reactive states that should trigger a datagrid re-generation
     */
    watch?: WatchSource[];
    /**
     * Use mutations to modify the dataset before it is mapped to the rendered rows and cells.
     */
    mutation?: DataGridFeatureMutation<TEntry>;
    /**
     * With `enhanceCell` the render details for a cell can be modified.
     * The provided function is called for every cell, after the matching typeRenderer was applied.
     *
     */
    enhanceCells?: {
        func: (cell: Readonly<DataGridRendererCell<TEntry>>, entry: Readonly<TEntry>, index: number) => {
            component?: DataGridRendererCell<TEntry>["component"];
            props?: Partial<DataGridRendererCell<TEntry>["props"]>;
            tdAttributes?: Partial<DataGridRendererCell<TEntry>["tdAttributes"]>;
        };
    } & Orderable;
    /**
     * Use `enhanceRow` the render details for a complete row can be modified.
     * The provided function is called for every row that is supposed to be rendered.
     */
    enhanceRow?: {
        func: (row: Readonly<DataGridRendererRow<TEntry>>, entry: Readonly<TEntry>, index: number) => Partial<DataGridRendererRow<TEntry>>;
    } & Orderable;
    /**
     * Allows defining actions that are displayed in the "action" slot above the data grid.
     * Will be automatically wrapped into a "more" flyout if not all actions fit
     * into the available width.
     */
    actions?: () => DataGridAction[];
    /**
     * Defines a renderer for a column type.
     */
    typeRenderer?: TTypeRenderer;
    /**
     * Allows modification of the normalized column configuration.
     * While the entries are passed as readonly, but the array itself can be modified.
     * To change entries, you need to clone them first:
     *
     * @example
     * ```ts
     * {
     *   modifyColumns: [ { func: (config) => configs.map(column => ({ ...column, type: "newType" })) } ];
     * }
     * ```
     */
    modifyColumns?: ModifyColumns<TEntry>;
    /**
     * Allows modification of the column groups.
     *
     *  @example
     * ```ts
     * {
     * modifyColumnGroups: {
     * func: (groups, columns) => {
     * return groups.flatMap(group => {
     * return [ { ...group, class: 'my-custom-group-class' } ];
     * });
     * }
     * }
     * }
     * ```
     */
    modifyColumnGroups?: ModifyColumnGroups<TEntry, ColumnGroupConfig>;
    /**
     * Allows the modification of the headers.
     */
    header?: {
        /**
         * Adds header icon button(s).
         * `iconComponent` of an action is shown after the header label.
         * The components must be ARIA-conform buttons.
         */
        actions?: (column: InternalColumnConfig<TEntry>, index: number, all: InternalColumnConfig<TEntry>[]) => {
            iconComponent?: Component | {
                iconComponent: Component;
                /**
                 * Will force the icon component to be always shown in the header and not be put into the menu
                 */
                alwaysShowInHeader?: boolean;
            };
            menuItems?: Component<typeof OnyxMenuItem>[];
            showFlyoutMenu?: boolean;
        }[];
        wrapper?: (column: InternalColumnConfig<TEntry>, index: number, all: InternalColumnConfig<TEntry>[]) => Component;
    };
    scrollContainerAttributes?: () => DataGridScrollContainerAttributes;
    tableAttributes?: () => DataGridTableAttributes;
    /**
     * Optional table slots.
     */
    slots?: DataGridFeatureSlots;
};
export type DataGridScrollContainerAttributes = HTMLAttributes & Pick<VNodeProps, "ref">;
export type DataGridTableAttributes = HTMLAttributes & Pick<VNodeProps, "ref">;
export type DataGridFeatureSlots = Partial<{
    [TSlotName in keyof Pick<OnyxTableSlots, "headline" | "bottomLeft" | "pagination" | "actions">]: (slotContent: () => VNode[]) => Nullable<VNode>[];
}>;
export type InternalDataGridSlots = Partial<Record<keyof DataGridFeatureSlots, () => VNode[]>>;
export type DataGridFeatureOptions<TEntry extends DataGridEntry, TColumnOptions extends Partial<Record<keyof TEntry, object>>, TWithAsync extends boolean = false> = {
    /**
     * Whether the feature is enabled by default. Can be overridden per column.
     *
     * @default true
     */
    enabled?: MaybeRef<boolean | undefined>;
    /**
     * Options for each column. Will override default/global options of the feature.
     */
    columns?: MaybeRef<{
        [TKey in keyof TEntry]?: TColumnOptions[TKey] & {
            /**
             * Whether the feature is enabled for this column. If unset, the default/global `enabled` option of this feature will be used.
             */
            enabled?: boolean;
        };
    } | undefined>;
} & (TWithAsync extends true ? {
    /**
     * When async is `true`, then the internal data transformations of this feature  are disabled and have to be performed manually.
     */
    async?: boolean;
} : unknown);
/**
 * Helper function that checks the generics of the DataGridFeature type, without breaking type inference.
 * @example
 * ```ts
 *
 * const MY_FEATURE = Symbol("TABLE_HEADER_BUTTON");
 * export const useDataGridHeaderButton = createFeature(<TEntry extends DataGridEntry>() => {
 *   return {
 *     name: MY_FEATURE,
 *     header: {
 *       actions: (column) => [
 *         {
 *           iconComponent: h('button', { onClick: (column) => console.log(`Clicked on ${column}`) },),
 *         },
 *       ],
 *     },
 *   };
 * });
 * ```
 */
export declare function createFeature<TFeature extends DataGridFeature<any, any, any>, T extends CheckDataGridFeature<TFeature>>(featureDefinition: T): T;
type CheckDataGridFeature<T> = T extends DataGridFeature<infer A, TypeRenderMap<infer A>, infer C> ? DataGridFeature<A, TypeRenderMap<A>, C> : never;
export type UseDataGridFeaturesOptions<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>> = {
    columnConfig: MaybeRefOrGetter<ColumnConfig<TEntry, TColumnGroup, TTypes>[]>;
    i18n: OnyxI18n;
    columnGroups: MaybeRefOrGetter<TColumnGroup>;
    async: Readonly<Ref<boolean>>;
    skeleton: DataGridFeatureContext["skeleton"];
};
export declare const createTableColumnGroups: <TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig>(columns?: InternalColumnConfig<TEntry, TColumnGroup>[], columnGroups?: ColumnGroupConfig) => TableColumnGroup[] | undefined;
export type ModifyColumnGroups<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig> = {
    func: (groups: TableColumnGroup[], columns: InternalColumnConfig<TEntry, TColumnGroup>[]) => TableColumnGroup[];
};
/**
 * Uses the defined datagrid features to provide factory functions.
 * These factories are to be used to map data and configuration to `OnyxDataGridRenderer` properties.
 * The properties are then used to render the data grid.
 *
 * Make use of the `watchSources` to trigger re-rendering when state changes occur.
 * @example
 * ```vue
 * <script setup lang="ts">
 * // ...
 * // imports, props, emits, etc.
 * const withHeaderButton = useDataGridHeaderButton<TEntry>();
 *
 * const { watchSources, createRendererRows, createRendererColumns } = useDataGridFeatures([withHeaderButton]);
 *
 * const renderCols: Ref<DataGridRendererColumn<TEntry, object>[]> = ref([]);
 * const renderRows: Ref<DataGridRendererRow<TEntry, DataGridMetadata>[]> = ref([]);
 *
 * const { columns, data } = toRefs(props);
 *
 * watch(
 *   [columns, data, ...watchSources],
 *   ([newColumns, newData]) => {
 *     renderCols.value = createRendererColumns(newColumns);
 *     renderRows.value = createRendererRows(newData, newColumns);
 *   },
 *   { immediate: true },
 * );
 * </script>
 * <template>
 *   <OnyxDataGridRenderer :columns="renderCols" :rows="renderRows" />
 * </template>
 * ```
 */
export declare const useDataGridFeatures: <TEntry extends DataGridEntry, TFeatureName extends symbol, TTypeRenderer extends TypeRenderMap<TEntry>, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>, T extends DataGridFeature<TEntry, TTypeRenderer, TFeatureName>[] | []>(featureDefinitions: T, { i18n, columnConfig, columnGroups, async, skeleton, }: UseDataGridFeaturesOptions<TEntry, TColumnGroup, TTypes>) => {
    /**
     * Returns the merged attributes that should be applied to the tables scroll-container.
     */
    createScrollContainerAttributes: () => never;
    /**
     * Returns the merged attributes that should be applied to the native <table> element.
     */
    createTableAttributes: () => never;
    /** Uses the column definition and available column group config to generate the column groups for the underlying OnyxTable */
    createRendererColumnGroups: () => TableColumnGroup[];
    /** Takes the column definition and maps all, calls mutation func and maps at the end to RendererCell */
    createRendererRows: (entries: TEntry[]) => DataGridRendererRow<TEntry, DataGridMetadata>[];
    /** Takes the column definition and creates a RenderHeader for each, adds actions from features */
    createRendererColumns: () => DataGridRendererColumn<TEntry>[];
    /** Uses all features and generates the content of the additional table slots (headline, pagination etc.) for the underlying OnyxTable */
    createSlots: () => Partial<Record<"pagination" | "headline" | "actions" | "bottomLeft", () => VNode[]>>;
    watchSources: WatchSource[];
};
export declare const useFeatureContext: (ctx: DataGridFeatureContext, options?: DataGridFeatureOptions<DataGridEntry, object, boolean>) => {
    /**
     * Checks whether a data grid feature is enabled for a given column.
     * Considers the feature defaults as well as column-specific overrides.
     *
     * @default true
     */
    isEnabled: import('vue').ComputedRef<(column?: PropertyKey) => boolean>;
    /**
     * Whether the feature only or all features have data transformations enabled.
     */
    isAsync: import('vue').ComputedRef<boolean>;
};
export {};