import { type PrimativeKey, type ReadKeyFunction } from '../key';
/**
 * How the value's presence changed from one set to the next.
 */
export declare enum SetDeltaChange {
    REMOVED = -1,
    NONE = 0,// No change
    ADDED = 1
}
/**
 * Returns true if the next value has been modified compared to the past value.
 */
export type SetValueIsModifiedFunction<T> = (past: T, next: T) => boolean;
/**
 * Represents the change status of a single value between two sets, including its past and next values.
 */
export interface SetDeltaChangePair<T, K extends PrimativeKey = PrimativeKey> {
    /**
     * Key for this pair
     */
    readonly key: K;
    /**
     * Value as it was in the past set, if applicable.
     */
    readonly pastValue?: T;
    /**
     * Value as it was in the next set, if applicable.
     */
    readonly nextValue?: T;
    /**
     * Evaluated value.
     */
    readonly value: T;
    /**
     * How the value changed.
     */
    readonly change: SetDeltaChange;
    /**
     * Whether or not the value was modified.
     */
    readonly isModified?: boolean;
}
/**
 * Function that builds an array of changes based on the values in the past array to the next array.
 */
export type SetDeltaFunction<T, K extends PrimativeKey = PrimativeKey> = (past: Iterable<T>, next: Iterable<T>) => SetDeltaChangePair<T, K>[];
/**
 * Configuration for creating a {@link SetDeltaFunction}.
 */
export interface SetDeltaFunctionConfig<T, K extends PrimativeKey = PrimativeKey> {
    /**
     * Reads the identifying key from each input value.
     */
    readKey: ReadKeyFunction<T, K>;
    /**
     * Whether or not the value is modified.
     */
    isModifiedFunction?: SetValueIsModifiedFunction<T>;
}
/**
 * Creates a {@link SetDeltaFunction} that computes the differences between two iterables,
 * identifying which items were added, removed, or unchanged.
 *
 * @param config - Configuration with the key reader and optional modification detector.
 * @returns A function that compares two iterables and returns an array of change pairs.
 */
export declare function setDeltaFunction<T>(config: SetDeltaFunctionConfig<T>): SetDeltaFunction<T>;
/**
 * Keys mapped by their change type.
 */
export interface SetDeltaChangeKeys<K extends PrimativeKey = PrimativeKey> {
    readonly removed: K[];
    readonly none: K[];
    readonly added: K[];
}
/**
 * Groups the keys from an array of {@link SetDeltaChangePair} values by their change type.
 *
 * @param pairs - The delta change pairs to categorize.
 * @returns An object with `added`, `removed`, and `none` key arrays.
 */
export declare function setDeltaChangeKeys<T, K extends PrimativeKey = PrimativeKey>(pairs: SetDeltaChangePair<T, K>[]): SetDeltaChangeKeys<K>;
/**
 * Pre-configured SetDeltaFunction for PrimativeKey values.
 */
export declare const primativeValuesDelta: <T extends PrimativeKey>(past: Iterable<T>, next: Iterable<T>) => SetDeltaChangePair<T, T>[];