import { Selector, EqualityFn } from './types';
/**
 * Create a memoized selector that only recomputes when dependencies change
 *
 * Similar to Reselect's createSelector, but optimized for Zustand.
 * Uses reference equality for dependencies and optional custom equality for results.
 *
 * @example
 * ```typescript
 * // Combine multiple primitive selectors into a computed value
 * const selectFullName = createSelector(
 *   [selectFirstName, selectLastName],
 *   (first, last) => `${first} ${last}`
 * );
 *
 * // With custom equality
 * const selectFilteredItems = createSelector(
 *   [selectItems, selectFilter],
 *   (items, filter) => items.filter(item => item.includes(filter)),
 *   shallow // Use shallow equality for array comparison
 * );
 * ```
 */
export declare function createSelector<TState, TDeps extends unknown[], TResult>(dependencySelectors: {
    [K in keyof TDeps]: Selector<TState, TDeps[K]>;
}, combiner: (...deps: TDeps) => TResult, equalityFn?: EqualityFn<TResult>): Selector<TState, TResult>;
/**
 * Create a selector that returns a stable object reference
 *
 * Use this for selectors that return objects to prevent unnecessary re-renders.
 * Uses shallow equality to compare object properties.
 *
 * @example
 * ```typescript
 * // This selector will return the same reference if properties are equal
 * const selectDisplaySettings = createObjectSelector((state) => ({
 *   locale: state.locale,
 *   timezone: state.timezone,
 *   dateFormat: state.dateFormat,
 * }));
 * ```
 */
export declare function createObjectSelector<TState, TResult extends object>(selector: Selector<TState, TResult>): Selector<TState, TResult>;
/**
 * Create a selector that returns a stable array reference
 *
 * Use this for selectors that return arrays to prevent unnecessary re-renders.
 * Uses element-wise reference equality comparison.
 *
 * @example
 * ```typescript
 * const selectActiveItems = createArraySelector((state) =>
 *   state.items.filter(item => item.active)
 * );
 * ```
 */
export declare function createArraySelector<TState, TItem>(selector: Selector<TState, TItem[]>): Selector<TState, TItem[]>;
/**
 * Create a parameterized selector (selector factory)
 *
 * Use this when you need selectors that depend on external parameters.
 * The returned function is memoized per parameter value with LRU eviction.
 *
 * @param factory - Factory function that creates a selector for each parameter
 * @param maxSize - Maximum cache size (default: 100). When exceeded, least recently used entries are evicted.
 *
 * @example
 * ```typescript
 * const selectItemById = createParameterizedSelector(
 *   (id: string) => (state) => state.items.find(item => item.id === id)
 * );
 *
 * // In component:
 * const item = useStore(selectItemById('123'));
 * ```
 */
export declare function createParameterizedSelector<TState, TParam, TResult>(factory: (param: TParam) => Selector<TState, TResult>, maxSize?: number): (param: TParam) => Selector<TState, TResult>;
/**
 * Create a parameterized selector with cache limit
 *
 * Same as createParameterizedSelector but with LRU cache eviction.
 * Use this when parameters can have many unique values.
 *
 * @example
 * ```typescript
 * const selectUserById = createBoundedParameterizedSelector(
 *   (id: string) => (state) => state.users[id],
 *   100 // Cache up to 100 selectors
 * );
 * ```
 */
export declare function createBoundedParameterizedSelector<TState, TParam, TResult>(factory: (param: TParam) => Selector<TState, TResult>, maxSize?: number): (param: TParam) => Selector<TState, TResult>;
/**
 * Combine multiple selectors into one with shallow equality
 *
 * Use this to select multiple values from state in a single hook call
 * while maintaining referential stability.
 *
 * @example
 * ```typescript
 * const selectUserProfile = combineSelectors({
 *   name: selectUserName,
 *   email: selectUserEmail,
 *   avatar: selectUserAvatar,
 * });
 *
 * // In component:
 * const { name, email, avatar } = useStore(selectUserProfile, shallow);
 * ```
 */
export declare function combineSelectors<TState, TResult extends Record<string, unknown>>(selectors: {
    [K in keyof TResult]: Selector<TState, TResult[K]>;
}): Selector<TState, TResult>;
/**
 * Create a selector that picks specific keys from state
 *
 * @example
 * ```typescript
 * const selectUIState = pickSelector<StoreState>()('sidebarOpen', 'activeModal');
 * ```
 */
export declare function pickSelector<TState>(): <K extends keyof TState>(...keys: K[]) => Selector<TState, Pick<TState, K>>;
/**
 * Create a selector that omits specific keys from state
 *
 * @example
 * ```typescript
 * const selectPublicState = omitSelector<StoreState>()('_internal', 'password');
 * ```
 */
export declare function omitSelector<TState extends object>(): <K extends keyof TState>(...keys: K[]) => Selector<TState, Omit<TState, K>>;
/**
 * Selector utility functions
 */
export declare const selectorUtils: {
    /**
     * Identity selector (passthrough)
     */
    identity: <T>(value: T) => T;
    /**
     * Create a selector with default value
     *
     * @example
     * ```typescript
     * const selectUserOrDefault = selectorUtils.withDefault(
     *   (state) => state.user,
     *   { name: 'Guest', email: '' }
     * );
     * ```
     */
    withDefault: <TState, T>(selector: Selector<TState, T | undefined | null>, defaultValue: T) => Selector<TState, T>;
    /**
     * Create a boolean selector from a predicate
     *
     * @example
     * ```typescript
     * const selectHasItems = selectorUtils.predicate(
     *   (state) => state.items,
     *   (items) => items.length > 0
     * );
     * ```
     */
    predicate: <TState, T>(selector: Selector<TState, T>, predicate: (value: T) => boolean) => Selector<TState, boolean>;
    /**
     * Create a mapped selector
     *
     * @example
     * ```typescript
     * const selectItemIds = selectorUtils.map(
     *   (state) => state.items,
     *   (items) => items.map(item => item.id)
     * );
     * ```
     */
    map: <TState, TInput, TOutput>(selector: Selector<TState, TInput>, transform: (value: TInput) => TOutput) => Selector<TState, TOutput>;
    /**
     * Create a filtered selector
     *
     * @example
     * ```typescript
     * const selectActiveItems = selectorUtils.filter(
     *   (state) => state.items,
     *   (item) => item.active
     * );
     * ```
     */
    filter: <TState, T>(selector: Selector<TState, T[]>, predicate: (item: T) => boolean) => Selector<TState, T[]>;
    /**
     * Create a find selector
     *
     * @example
     * ```typescript
     * const selectFirstActiveItem = selectorUtils.find(
     *   (state) => state.items,
     *   (item) => item.active
     * );
     * ```
     */
    find: <TState, T>(selector: Selector<TState, T[]>, predicate: (item: T) => boolean) => Selector<TState, T | undefined>;
};