export type SortDirection = "asc" | "desc" | null;
export type SortKey<T> = keyof T | null;
export interface SortConfig<T> {
    key: SortKey<T>;
    direction: SortDirection;
}
export interface SortableDataOptions<T> {
    /** Initial sort configuration */
    initialSort?: SortConfig<T>;
    /** Custom sort function */
    customSort?: (a: T, b: T, key: keyof T, direction: SortDirection) => number;
    /** Enable multi-column sorting */
    multiSort?: boolean;
    /** Maximum number of sort levels for multi-sort */
    maxSortLevels?: number;
    /** Stable sort (preserves original order for equal items) */
    stable?: boolean;
    /** Case-sensitive sorting for strings */
    caseSensitive?: boolean;
    /** Null/undefined handling */
    nullsFirst?: boolean;
    /** Custom value getter for sorting */
    getValue?: (item: T, key: keyof T) => unknown;
}
export interface SortableDataResult<T> {
    /** Sorted data */
    data: T[];
    /** Current sort configuration */
    sortConfig: SortConfig<T>;
    /** Multi-sort configurations */
    sortConfigs: SortConfig<T>[];
    /** Sort function */
    sort: (key: keyof T, direction?: SortDirection, append?: boolean) => void;
    /** Clear all sorting */
    clearSort: () => void;
    /** Toggle sort direction */
    toggleSort: (key: keyof T) => void;
    /** Check if column is sorted */
    isSorted: (key: keyof T) => boolean;
    /** Get sort direction for column */
    getSortDirection: (key: keyof T) => SortDirection;
    /** Get sort priority for column (for multi-sort) */
    getSortPriority: (key: keyof T) => number | null;
}
export declare function useSortableData<T>(data: T[], options?: SortableDataOptions<T>): SortableDataResult<T>;
export declare function useSearchableSortableData<T>(data: T[], searchFields: (keyof T)[], options?: SortableDataOptions<T> & {
    searchQuery?: string;
    searchDebounce?: number;
    caseSensitive?: boolean;
    fuzzy?: boolean;
}): {
    filteredData: T[];
    searchQuery: string;
    totalCount: number;
    filteredCount: number;
    /** Sorted data */
    data: T[];
    /** Current sort configuration */
    sortConfig: SortConfig<T>;
    /** Multi-sort configurations */
    sortConfigs: SortConfig<T>[];
    /** Sort function */
    sort: (key: keyof T, direction?: SortDirection, append?: boolean) => void;
    /** Clear all sorting */
    clearSort: () => void;
    /** Toggle sort direction */
    toggleSort: (key: keyof T) => void;
    /** Check if column is sorted */
    isSorted: (key: keyof T) => boolean;
    /** Get sort direction for column */
    getSortDirection: (key: keyof T) => SortDirection;
    /** Get sort priority for column (for multi-sort) */
    getSortPriority: (key: keyof T) => number | null;
};
export declare function usePaginatedSortableData<T>(data: T[], itemsPerPage?: number, options?: SortableDataOptions<T> & {
    initialPage?: number;
    onPageChange?: (page: number) => void;
}): {
    data: T[];
    currentPage: number;
    totalPages: number;
    itemsPerPage: number;
    totalItems: number;
    goToPage: (page: number) => void;
    nextPage: () => void;
    previousPage: () => void;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    /** Current sort configuration */
    sortConfig: SortConfig<T>;
    /** Multi-sort configurations */
    sortConfigs: SortConfig<T>[];
    /** Sort function */
    sort: (key: keyof T, direction?: SortDirection, append?: boolean) => void;
    /** Clear all sorting */
    clearSort: () => void;
    /** Toggle sort direction */
    toggleSort: (key: keyof T) => void;
    /** Check if column is sorted */
    isSorted: (key: keyof T) => boolean;
    /** Get sort direction for column */
    getSortDirection: (key: keyof T) => SortDirection;
    /** Get sort priority for column (for multi-sort) */
    getSortPriority: (key: keyof T) => number | null;
};
export declare const sortUtils: {
    naturalSort: (a: string, b: string, direction?: SortDirection) => number;
    weightedSort: <T>(items: T[], criteria: Array<{
        key: keyof T;
        weight: number;
        direction?: SortDirection;
    }>) => T[];
    groupSort: <T, K extends keyof T>(items: T[], groupBy: K, sortBy: K, direction?: SortDirection) => T[];
};
//# sourceMappingURL=useSortableData.d.ts.map