import { Intersection, Primitive, Serial, Dictionary } from 'type-core';

type Select<T extends Select.Selector, A extends boolean = false, G extends Select.Strategy = 'fallback'> = Exclude<unknown extends T['default'] ? T[keyof T] | undefined : G extends 'fallback' ? T[keyof T] : T[Exclude<keyof T, 'default'>] & T['default'], A extends true ? undefined : never>;
declare namespace Select {
    interface Options<A extends boolean = boolean, G extends Strategy = Strategy> {
        name?: string;
        assert?: A;
        strategy?: G;
    }
    type Strategy = 'fallback' | 'shallow' | 'merge' | 'deep';
    type Selector<T extends Intersection<Primitive, Serial> = Intersection<Primitive, Serial>, S = Dictionary<Serial>> = S & {
        [P in Value<T>]?: Serial;
    };
    type Value<T extends Intersection<Primitive, Serial>> = (T extends string ? T : never) | (T extends undefined ? 'undefined' : never) | (T extends void ? 'undefined' : never) | (T extends null ? 'null' : never) | (T extends boolean ? 'true' | 'false' : never) | (T extends number ? string : never);
}
declare function select<T extends Intersection<Primitive, Serial>, S extends Select.Selector, A extends boolean = false, G extends Select.Strategy = 'fallback'>(data: T, selector: Select.Selector<T, S>, options?: Select.Options<A, G>): Select<S, A, G>;

export { Select, select };