// @flow

// type names ----------------------------------------------------------------

export type Cleaner<T> = (raw: any) => T

export type Uncleaner<T> = (clean: T) => any

export type ObjectCleaner<T> = Cleaner<T> & {
  +shape: $ObjMap<T, <T>(type: T) => Cleaner<T>>,
  +withRest: Cleaner<T>
}

type ReturnType = <T>(f: () => T) => T

// simple types --------------------------------------------------------------

declare export var asBoolean: Cleaner<boolean>
declare export var asNone: Cleaner<void>
declare export var asNull: Cleaner<null>
declare export var asNumber: Cleaner<number>
declare export var asString: Cleaner<string>
declare export var asUndefined: Cleaner<void>
declare export var asUnknown: Cleaner<mixed>

declare export function asValue<
  T: Array<boolean | number | string | null | void>
>(
  ...values: T
): Cleaner<$ElementType<T, number>>

// data structures -----------------------------------------------------------

declare export function asArray<T>(cleaner: Cleaner<T>): Cleaner<T[]>

declare export var asObject: {|
  <T>(cleaner: Cleaner<T>): Cleaner<{ [keys: string]: T }>,
  <Shape>(shape: Shape): ObjectCleaner<$ObjMap<Shape, ReturnType>>
|}

declare export function asTuple<Shape>(
  ...shape: Shape
): Cleaner<$TupleMap<Shape, ReturnType>>

// branching -----------------------------------------------------------------

declare export var asEither: {|
  <A>(a: Cleaner<A>): Cleaner<A>,
  <A, B>(a: Cleaner<A>, b: Cleaner<B>): Cleaner<A | B>,
  <A, B, C>(a: Cleaner<A>, b: Cleaner<B>, c: Cleaner<C>): Cleaner<A | B | C>,
  <A, B, C, D>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>
  ): Cleaner<A | B | C | D>,
  <A, B, C, D, E>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>
  ): Cleaner<A | B | C | D | E>,
  <A, B, C, D, E, F>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>
  ): Cleaner<A | B | C | D | E | F>,
  <A, B, C, D, E, F, G>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>
  ): Cleaner<A | B | C | D | E | F | G>,
  <A, B, C, D, E, F, G, H>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>
  ): Cleaner<A | B | C | D | E | F | G | H>,
  <A, B, C, D, E, F, G, H, I>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>
  ): Cleaner<A | B | C | D | E | F | G | H | I>,
  <A, B, C, D, E, F, G, H, I, J>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J>,
  <A, B, C, D, E, F, G, H, I, J, K>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>,
    k: Cleaner<K>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J | K>,
  <A, B, C, D, E, F, G, H, I, J, K, L>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>,
    k: Cleaner<K>,
    l: Cleaner<L>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L>,
  <A, B, C, D, E, F, G, H, I, J, K, L, M>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>,
    k: Cleaner<K>,
    l: Cleaner<L>,
    m: Cleaner<M>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M>,
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>,
    k: Cleaner<K>,
    l: Cleaner<L>,
    m: Cleaner<M>,
    n: Cleaner<N>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M | N>,
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>,
    k: Cleaner<K>,
    l: Cleaner<L>,
    m: Cleaner<M>,
    n: Cleaner<N>,
    o: Cleaner<O>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O>,
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
    a: Cleaner<A>,
    b: Cleaner<B>,
    c: Cleaner<C>,
    d: Cleaner<D>,
    e: Cleaner<E>,
    f: Cleaner<F>,
    g: Cleaner<G>,
    h: Cleaner<H>,
    i: Cleaner<I>,
    j: Cleaner<J>,
    k: Cleaner<K>,
    l: Cleaner<L>,
    m: Cleaner<M>,
    n: Cleaner<N>,
    o: Cleaner<O>,
    p: Cleaner<P>
  ): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P>
|}

declare export var asMaybe: {|
  <T>(cleaner: Cleaner<T>): Cleaner<T | void>,
  <T>(
    cleaner: Cleaner<T>,
    // The extra $Call prevents Flow from inferring T from the fallback:
    fallback: $Call<Cleaner<T>> | (() => $Call<Cleaner<T>>)
  ): Cleaner<T>
|}

declare export var asOptional: {|
  <T>(cleaner: Cleaner<T>): Cleaner<T | void>,
  <T>(
    cleaner: Cleaner<T>,
    // The extra $Call prevents Flow from inferring T from the fallback:
    fallback: $Call<Cleaner<T>> | (() => $Call<Cleaner<T>>)
  ): Cleaner<T>
|}

// parsing -------------------------------------------------------------------

declare export function asCodec<T>(
  cleaner: Cleaner<T>,
  uncleaner: Uncleaner<T>
): Cleaner<T>

declare export var asDate: Cleaner<Date>

declare export function asJSON<T>(cleaner: Cleaner<T>): Cleaner<T>

declare export function uncleaner<T>(cleaner: Cleaner<T>): Uncleaner<T>

// deprecated ----------------------------------------------------------------

declare export var asMap: typeof asObject