import { Dictionary, Callable, Serial, Intersection, Primitive } from 'type-core';
import { Schema } from '../../definitions/index.js';
import { Assert } from '../assert.js';
import { Take } from '../take.js';
import { Ensure } from '../ensure/ensure.js';
import { Coerce } from '../coerce.js';
import { Select } from '../select.js';
import 'json-schema';
import '../ensure/types.js';

type Collect<O> = {
    [P in keyof O]: O[P] extends Collect.Collector ? ReturnType<O[P]> : never;
};
declare namespace Collect {
    interface Options {
        failEarly: boolean;
    }
    type Collection<O extends Dictionary<Collector>> = Callable<Actions, O>;
    type Collector<T = any> = Callable<Serial, T>;
    interface Actions {
        get: () => Collector<Serial>;
        assert: <D extends boolean = false>(options?: Assert.Options) => Collector<Assert<Serial, D>>;
        take: <A extends boolean = false>(options?: Take.Options<A>) => Collector<Take<Serial, A>>;
        ensure: <D extends Serial, E extends Serial, N extends Schema.TypeName = never, A extends boolean = false>(schema: Ensure.Schema<any, D, E, N>, options?: Ensure.Options<A>) => Collector<Ensure<Serial, D, E, N, A>>;
        coerce: <D extends Serial, E extends Serial, N extends Schema.TypeName, A extends boolean = false>(schema: Coerce.Schema<D, E, N>, options?: Coerce.Options<A>) => Collector<Coerce<D, E, N, A>>;
        select: <S extends Select.Selector, G extends Select.Strategy = 'fallback', A extends boolean = false>(selector: Select.Selector<Intersection<Primitive, Serial>, S>, options?: Select.Options<A, G>) => Collector<Select<S, A, G>>;
    }
}
declare function collect<I extends Dictionary<Serial>, O extends Dictionary<Collect.Collector>>(data: I, collection: Collect.Collection<O>, options?: Collect.Options): Collect<O>;

export { Collect, collect };