import { ColGroupDef, GridApi, GridOptions, ICellRendererParams, RowSelectionOptions, ValueSetterParams } from 'ag-grid-enterprise';
import { Component } from 'vue';
import { ColDefExtended } from './createAgGridColDef';
import { ImportFileHandle, ImportProgress } from '@platforma-sdk/model';
interface GridOptionsExtended<TData = any> extends Omit<GridOptions<TData>, "columnDefs" | "loadingOverlayComponentParams"> {
    /**
     * Array of Column / Column Group definitions.
     */
    columnDefs?: (ColDefExtended<TData> | ColGroupDef<TData>)[] | null;
    /**
     * Show row numbers column
     */
    rowNumbersColumn?: boolean;
    /**
     * Loading overlay text
     */
    loadingText?: string;
    /**
     * Not ready overlay (Data is not computed). Takes priority over "loading"
     */
    notReady?: boolean;
    /**
     * "Data is not computed" by default
     */
    notReadyText?: string;
    /**
     * Override standard 'Empty' text for the "no rows" overlay
     */
    noRowsText?: string;
    /**
     * @deprecated Use loading, notReady, loadingText instead
     */
    loadingOverlayComponentParams?: never;
}
declare class Builder<TData> {
    #private;
    options(options: GridOptionsExtended<TData>): this;
    private get columnDefs();
    /**
     * Set default column definition
     * @param def - column definition
     * @returns this
     */
    setDefaultColDef(def: ColDefExtended<TData>): this;
    /**
     * Show loading overlay
     * @param loading
     * @returns this
     */
    setLoading(loading?: boolean): this;
    /**
     * Set loading overlay custom text (default is "Loading")
     * @param loadingText
     * @returns this
     */
    setLoadingText(loadingText?: string): this;
    /**
     * Show "not ready overlay
     * @param notReady
     * @returns this
     */
    setNotReady(notReady?: boolean): this;
    /**
     * Set "not ready" text
     * @param notReadyText
     * @returns this
     */
    setNotReadyText(notReadyText?: string): this;
    /**
     * Set "no rows" text when there are no rows (default is "Empty")
     * @param noRowsText
     * @returns this
     */
    setNoRowsText(noRowsText?: string): this;
    /**
     * Set row selection options
     * @param rowSelection
     * @returns this
     */
    setRowSelection(rowSelection?: RowSelectionOptions): this;
    /**
     * Set row data
     * @param rowData
     * @returns this
     */
    setRowData(rowData?: TData[]): this;
    /**
     * Set components
     * @param components
     * @returns this
     */
    setComponents(components?: Record<string, Component>): this;
    /**
     * Set an option
     * @param key - option key
     * @param value - option value
     * @returns this
     */
    setOption<K extends keyof GridOptionsExtended<TData>>(key: K, value: GridOptionsExtended<TData>[K]): this;
    /**
     * Add an extended column definition
     * @param def - column definition
     * @returns this
     */
    column<TValue = any>(def: ColDefExtended<TData, TValue>): this;
    /**
     * Show row numbers column
     * @param show - show or hide row numbers column
     * @returns this
     */
    columnRowNumbers(show?: boolean): this;
    /**
     * Add a file input column
     * @param def - column definition
     * @param cb - callback to set params for the file input cell renderer
     * @returns this
     */
    columnFileInput<TValue = any>(def: ColDefExtended<TData, TValue> & {
        /**
         * Allowed file extensions (like ['fastq.gz'])
         */
        extensions?: string[];
        /**
         * The resolveProgress function is an optional input parameter for the component
         * that allows tracking the file upload progress in real-time.
         * By passing resolveProgress, you can ensure that the component
         * displays accurate progress values for each file as they upload.
         * How to use it in AgGrid
         * cellRendererParams: {
         *  resolveProgress: (cellData) => {
         *    const progresses = app.progresses;
         *    if (!cellData.value.importFileHandle) return undefined;
         *    else return progresses[cellData.value.importFileHandle];
         *  }
         * }
         */
        resolveImportProgress?: (cellData: ICellRendererParams<TData, TValue>) => ImportProgress | undefined;
        /**
         * The resolveFileHandle function is an optional input parameter for the component
         * that allows tracking the file upload progress in real-time.
         * By passing resolveFileHandle, you can ensure that the component
         * displays accurate progress values for each file as they upload.
         * How to use it in AgGrid
         * cellRendererParams: {
         *  resolveFileHandle: (cellData) => {
         *    return cellData.value.importFileHandle;
         *  }
         * }
         */
        resolveImportFileHandle?: (cellData: ICellRendererParams<TData, TValue>) => ImportFileHandle | undefined;
        setImportFileHandle?: (d: ValueSetterParams<TData, ImportFileHandle | undefined>) => void;
    }): this;
    build(): GridOptionsExtended<TData>;
}
type ColumnFunc<TData> = <TValue>(def: ColDefExtended<TData, TValue>) => ColDefExtended<TData, TValue>;
/**
 * Returns a set of Ag Grid options along with a reference to the Ag Grid API.
 * (This is a fast prototype)
 *
 * @example
 * ```ts
 * const { gridOptions, gridApi } = useAgGridOptions(() => ({
 *   // custom grid options here
 * }));
 *
 * // Usage in a template (v-bind is required!)
 * <template>
 *   <AgGridVue :style="{ height: '100%' }" v-bind="gridOptions" />
 * </template>
 * ```
 */
export declare function useAgGridOptions<TData>(factory: (context: {
    builder: Builder<TData>;
    column: ColumnFunc<TData>;
}) => Builder<TData> | GridOptionsExtended<TData>): {
    gridOptions: import('vue').ComputedRef<GridOptions<any>>;
    gridApi: import('vue').ShallowRef<GridApi<any> | undefined, GridApi<any> | undefined>;
};
export {};
//# sourceMappingURL=useAgGridOptions.d.ts.map