import { AnySafeMapper, Name, ExtendedMapper, OutputOf, MappableInputOf, AnyMapper, AssertPipeable, SafeMapper } from "../mapper";
import * as m from "../functional-lib";
import { FluentMapper } from "../fluent-mapper";
import { Enum, EnumKey } from "../enum-util";
import { ToOneEnumValueMapper, ToOneEnumKeyMapper, ObjectFromArrayMapper, ObjectFromMapMapper, CastDelegate, PipeMapper } from "../functional-lib";
import { LiteralType } from "../primitive";
import { FieldMap, SafeMapperMap } from "../field-map";
export declare function arrayLike<F extends AnySafeMapper>(f: F): (FluentMapper<m.ArrayLikeMapper<F>>);
export declare function arrayLikeToArray<F extends AnySafeMapper>(f: F): (FluentMapper<m.ArrayLikeToArrayMapper<F>>);
export declare function arrayLikeToReadOnlyArray<F extends AnySafeMapper>(f: F): (FluentMapper<m.ArrayLikeToReadOnlyArrayMapper<F>>);
export declare function array<F extends AnySafeMapper>(f: F): (FluentMapper<m.ArrayMapper<F>>);
export declare function readOnlyArray<F extends AnySafeMapper>(f: F): (FluentMapper<m.ReadOnlyArrayMapper<F>>);
export declare type FluentCastEnumFlyweight<E extends typeof Enum> = ({
    toValue: {
        [k in EnumKey<E>]: (FluentMapper<ToOneEnumValueMapper<E, k>>);
    };
    toKey: {
        [k in EnumKey<E>]: (FluentMapper<ToOneEnumKeyMapper<E, k>>);
    };
});
export declare function castEnumFlyweight<E extends typeof Enum>(e: E): FluentCastEnumFlyweight<E>;
export declare function toEnumValue<E extends typeof Enum>(e: E): (FluentMapper<m.ToEnumValueMapper<E>>);
export declare function toEnumKey<E extends typeof Enum>(e: E): (FluentMapper<m.ToEnumKeyMapper<E>>);
export declare function toOneEnumValue<E extends typeof Enum, K extends EnumKey<E>>(e: E, k: K): (FluentMapper<m.ToOneEnumValueMapper<E, K>>);
export declare function toOneEnumKey<E extends typeof Enum, K extends EnumKey<E>>(e: E, k: K): (FluentMapper<m.ToOneEnumKeyMapper<E, K>>);
export declare function enumKey<E extends typeof Enum>(e: E): (FluentMapper<m.EnumKeyMapper<E>>);
export declare function enumValue<E extends typeof Enum>(e: E): (FluentMapper<m.EnumValueMapper<E>>);
export declare function unsafeLiteral<ArrT extends LiteralType[]>(...arr: ArrT): (FluentMapper<m.UnsafeLiteralMapper<ArrT>>);
export declare function literal<Arg0 extends LiteralType, ArrT extends LiteralType[]>(arg0: Arg0, ...arr: ArrT): (FluentMapper<m.LiteralMapper<Arg0, ArrT>>);
export declare function tupleLiteral<TupleT extends readonly LiteralType[]>(...tuple: TupleT): (FluentMapper<m.TupleLiteralMapper<TupleT>>);
export declare function deriveMap<MapT extends FieldMap>(map: MapT): (FluentMapper<m.DeriveMapMapper<MapT>>);
export declare function derive<SrcKeyT extends string, DstKeyT extends string, F extends AnySafeMapper>(srcKey: SrcKeyT, dstKey: DstKeyT, f: F): (FluentMapper<m.DeriveMapper<SrcKeyT, DstKeyT, F>>);
export declare function instanceOf<T>(ctor: new (...args: any[]) => T): (FluentMapper<m.InstanceOfMapper<T>>);
export declare function objectFromArray<ArrT extends (AnySafeMapper & Name<string>)[]>(...arr: ArrT): (FluentMapper<m.ObjectFromArrayMapper<ArrT>>);
export declare function objectFromMap<MapT extends SafeMapperMap>(map: MapT): (FluentMapper<m.ObjectFromMapMapper<MapT>>);
export interface ObjectMapperCreator {
    <ArrT extends (AnySafeMapper & Name<string>)[]>(...arr: ArrT): (FluentMapper<ObjectFromArrayMapper<ArrT>>);
    <MapT extends SafeMapperMap>(map: MapT): (FluentMapper<ObjectFromMapMapper<MapT>>);
}
export declare const object: ObjectMapperCreator;
export declare function partialDeriveMap<MapT extends FieldMap>(map: MapT): (FluentMapper<m.PartialDeriveMapMapper<MapT>>);
export declare function partialObjectFromArray<ArrT extends (AnySafeMapper & Name<string>)[]>(...arr: ArrT): (FluentMapper<m.PartialObjectFromArrayMapper<ArrT>>);
export declare function partialObjectFromMap<MapT extends SafeMapperMap>(map: MapT): (FluentMapper<m.PartialObjectFromMapMapper<MapT>>);
export interface PartialObjectMapperCreator {
    <ArrT extends (AnySafeMapper & Name<string>)[]>(...arr: ArrT): (FluentMapper<m.PartialObjectFromArrayMapper<ArrT>>);
    <MapT extends SafeMapperMap>(map: MapT): (FluentMapper<m.PartialObjectFromMapMapper<MapT>>);
}
export declare const partialObject: PartialObjectMapperCreator;
export declare function partialRenameMap<MapT extends FieldMap>(map: MapT): (FluentMapper<m.PartialRenameMapMapper<MapT>>);
export declare function renameMap<MapT extends FieldMap>(map: MapT): (FluentMapper<m.RenameMapMapper<MapT>>);
export declare function rename<SrcKeyT extends string, DstKeyT extends string, F extends AnySafeMapper>(srcKey: SrcKeyT, dstKey: DstKeyT, f: F): (FluentMapper<m.RenameMapper<SrcKeyT, DstKeyT, F>>);
export declare function unsafeStringIndexer<F extends AnySafeMapper>(f: F): (FluentMapper<m.UnsafeStringIndexerMapper<F>>);
export declare function stringIndexer<F extends AnySafeMapper>(f: F): (FluentMapper<m.StringIndexerMapper<F>>);
export declare function cache<CachedT, F extends ExtendedMapper<any, any, [CachedT]>>(cached: CachedT, f: F): (FluentMapper<m.CacheMapper<CachedT, F>>);
export declare function cast<SrcF extends AnySafeMapper, DstF extends AnySafeMapper>(srcDelegate: SrcF, castDelegate: CastDelegate<OutputOf<SrcF>, MappableInputOf<DstF>>, dstDelegate: DstF): (FluentMapper<m.CastMapper<SrcF, DstF>>);
export declare function unsafeDeepMerge<ArrT extends AnySafeMapper[]>(...arr: ArrT): (FluentMapper<m.UnsafeDeepMergeMapper<ArrT>>);
export declare function deepMerge<F extends AnySafeMapper, ArrT extends AnySafeMapper[]>(f: F, ...arr: ArrT): (FluentMapper<m.DeepMergeMapper<F, ArrT>>);
export declare function excludeLiteral<F extends AnySafeMapper, ArrT extends LiteralType[]>(f: F, ...arr: ArrT): (FluentMapper<m.ExcludeLiteralMapper<F, ArrT>>);
export declare function orUndefined<F extends AnySafeMapper>(f: F): (FluentMapper<m.OrUndefinedMapper<F>>);
export declare function orNull<F extends AnySafeMapper>(f: F): (FluentMapper<m.OrNullMapper<F>>);
export declare function orMaybe<F extends AnySafeMapper>(f: F): (FluentMapper<m.OrMaybeMapper<F>>);
export declare function notUndefined<F extends AnySafeMapper>(f: F): (FluentMapper<m.NotUndefinedMapper<F>>);
export declare function notNull<F extends AnySafeMapper>(f: F): (FluentMapper<m.NotNullMapper<F>>);
export declare function notMaybe<F extends AnySafeMapper>(f: F): (FluentMapper<m.NotMaybeMapper<F>>);
export declare function optional<F extends AnySafeMapper>(f: F): (FluentMapper<m.OptionalMapper<F>>);
export declare function notOptional<F extends AnySafeMapper>(f: F): (FluentMapper<m.NotOptionalMapper<F>>);
export declare function unsafeOr<ArrT extends AnySafeMapper[]>(...arr: ArrT): (FluentMapper<m.UnsafeOrMapper<ArrT>>);
export declare function or<F extends AnySafeMapper, ArrT extends AnySafeMapper[]>(f: F, ...arr: ArrT): (FluentMapper<m.OrMapper<F, ArrT>>);
export interface PipeMapperCreator {
    <F0 extends AnySafeMapper, F1 extends AnyMapper>(f0: F0, f1: AssertPipeable<F0, F1>): (FluentMapper<PipeMapper<F0, F1>>);
    <F0 extends AnySafeMapper, F1 extends AnyMapper, F2 extends AnyMapper>(f0: F0, f1: AssertPipeable<F0, F1>, f2: AssertPipeable<F1, F2>): (FluentMapper<PipeMapper<F0, F2>>);
    <F0 extends AnySafeMapper, F1 extends AnyMapper, F2 extends AnyMapper, F3 extends AnyMapper>(f0: F0, f1: AssertPipeable<F0, F1>, f2: AssertPipeable<F1, F2>, f3: AssertPipeable<F2, F3>): (FluentMapper<PipeMapper<F0, F3>>);
    <F0 extends AnySafeMapper, F1 extends AnyMapper, F2 extends AnyMapper, F3 extends AnyMapper, F4 extends AnyMapper>(f0: F0, f1: AssertPipeable<F0, F1>, f2: AssertPipeable<F1, F2>, f3: AssertPipeable<F2, F3>, f4: AssertPipeable<F3, F4>): (FluentMapper<PipeMapper<F0, F4>>);
}
export declare const pipe: PipeMapperCreator;
export declare function unsafePipe<SrcF extends AnySafeMapper, ArrT extends AnyMapper[]>(f: SrcF, ...arr: ArrT): (FluentMapper<m.UnsafePipeMapper<SrcF>>);
export declare function reallyUnsafePipe<ArrT extends AnyMapper[]>(...arr: ArrT): (FluentMapper<SafeMapper<unknown>>);
export declare function deferred<OutputT>(): (FluentMapper<m.DeferredMapper<OutputT>>);
//# sourceMappingURL=generic.d.ts.map