import { FilterValues, UseFilterOptions, UseFilterReturn } from './useFilter';
/** Et filtervalg med verdi og visningstekst */
export interface FilterOption<V = string> {
    value: V;
    label: string;
}
type OptionValue<V> = V extends (infer U)[] ? U : V;
/** Konfigurasjon for en filterkategori. */
export interface FilterCategoryConfig<V = unknown> {
    options?: ({
        value: OptionValue<V>;
    } & {
        [key: string]: any;
    })[];
    defaultValue?: V;
    /** Hent visningstekst fra et option-objekt. Hvis ikke satt, brukes String(value). */
    getLabel?: (option: any) => string;
}
export interface FilterConfigResult<T extends FilterValues> {
    /** Options for useFilter (defaultValues) */
    filterOptions: UseFilterOptions<T>;
    /** Look up the display label for a filter value */
    getLabel: (key: keyof T, value: unknown) => string;
}
/**
 * Lager UseFilterOptions fra et oppsett av filterkategorier.
 * Samler defaultValues og label-oppslag automatisk fra config.
 *
 * Eksempel:
 *   const { filterOptions, getLabel } = createFilterConfig<MyFilters>({
 *     sykehus: { options: sykehusOptions, defaultValue: ['haukeland'], getLabel: o => o.label },
 *     status: { options: statusOptions, getLabel: o => o.displayText },
 *   });
 *   const filter = useFilter(filterOptions);
 *   getLabel('sykehus', 'haukeland') // → 'Haukeland universitetssjukehus'
 */
export declare const createFilterConfig: <T extends FilterValues>(categories: { [K in keyof T]?: FilterCategoryConfig<T[K]>; }) => FilterConfigResult<T>;
/**
 * Ferdige matcher-funksjoner for typiske filter mønster.
 * Brukes som deler i matcher objektet til filterItems.
 *
 * Eksempel:
 *   const filterMatchers = {
 *     categories: matchFilter.arrayIncludes<Medisin>(m => m.sykehus),
 *     status: matchFilter.exactMatch<Medisin>(m => m.status),
 *     eResept: matchFilter.booleanToggle<Medisin>(m => m.eResept),
 *   };
 */
export declare const matchFilter: {
    /** Array-filter: matcher hvis det er overlapp mellom filterverdier og item-verdier (OR-logikk). */
    arrayIncludes: <TItem>(accessor: (item: TItem) => unknown) => (item: TItem, value: unknown) => boolean;
    /** Eksakt match: matcher hvis item-verdien er lik én av filterverdiene */
    exactMatch: <TItem>(accessor: (item: TItem) => unknown) => (item: TItem, value: unknown) => boolean;
    /** Boolean toggle: når filterverdien er true, inkluder kun items der accessor returnerer true */
    booleanToggle: <TItem>(accessor: (item: TItem) => boolean) => (item: TItem, value: unknown) => boolean;
    /** Fritekstsøk: matcher hvis søketeksten finnes i ett eller flere felt (case-insensitive) */
    textSearch: <TItem>(...accessors: ((item: TItem) => string | undefined)[]) => (item: TItem, value: unknown) => boolean;
};
/**
 * Filtrerer en liste med items basert på aktive filterverdier.
 * Hvert filter som er satt må matche for at et item skal inkluderes (AND-logikk).
 *
 * Eksempel:
 *   const filtered = filterItems(medisiner, filter.filters, {
 *     sykehus: matchFilter.arrayIncludes<Medisin>(m => m.sykehus),
 *     reseptstatus: matchFilter.exactMatch<Medisin>(m => m.reseptstatus),
 *     eResept: matchFilter.booleanToggle<Medisin>(m => m.eResept),
 *   });
 */
/** Type for matcher-objektet som sendes til filterItems. Sikrer at keys matcher filtertypen. */
export type FilterMatchers<TItem, T extends FilterValues> = {
    [K in keyof T]?: (item: TItem, value: NonNullable<T[K]>) => boolean;
};
export declare const filterItems: <TItem, T extends FilterValues>(items: TItem[], filters: Partial<T>, matchers: FilterMatchers<TItem, T>) => TItem[];
/**
 * Toggler en verdi i et array-basert filter.
 * Legger til verdien hvis den ikke finnes, fjerner den hvis den finnes.
 * Setter filteret til undefined hvis arrayet blir tomt.
 */
export declare const toggleArrayFilter: <T extends FilterValues, K extends keyof T>(filter: UseFilterReturn<T>, filterKey: K, value: T[K] extends (infer U)[] | undefined ? U : never) => void;
export {};