shades/types/index.d.ts

Lens-like functionality with a lodash-style interface.

// TypeScript Version: 3.4
import {
  Functor,
  Unpack,
  HasKey,
  KeyAt,
  Collection,
  Container,
  Fill,
  FillingPattern,
  Indexable,
  Index,
  InputType,
  HasPattern,
  Fn0,
  Fn1,
  Fn2,
  Fn3,
  Fn4,
  Fn5,
  Fn6,
  Fn7,
  Fn8,
  Traversal,
  Lens
} from './utils';

export { Lens, Traversal } from './utils';

export function into<Fn extends (...a: any[]) => any>(f: Fn): Fn;
export function into<Key extends string>(f: Key): <Obj extends HasKey<Key>>(s: Obj) => Obj[Key];
export function into<Pattern extends object>(p: Pattern): (o: HasPattern<Pattern>) => boolean;




export function maxOf<Key extends string>(k: Key): <Item extends HasKey<Key, number>>(acc: Item, current: Item) => Item
export function maxOf<A>(f: (a: A) => number): (acc: A, current: A) => A

export function minOf<Key extends string>(k: Key): <Item extends HasKey<Key, number>>(acc: Item, current: Item) => Item
export function minOf<Item>(f: (a: Item) => number): (acc: Item, current: Item) => Item

export function findOf<Key extends string>(k: Key): <Item extends HasKey<Key>>(acc: Item, item: Item) => Item
export function findOf<Item>(f: (a: Item) => any): (acc: Item, current: Item) => Item
export function findOf<Pattern>(p: Pattern): <Item extends HasPattern<Pattern>>(acc: Item, item: Item) => Item

export function sumOf<Key extends string>(k: Key): (acc: number, current: HasKey<Key, number>) => number
export function sumOf<A>(f: (a: A) => number): (acc: number, current: A) => number

export function productOf<Key extends string>(k: Key): (acc: number, current: HasKey<Key, number>) => number
export function productOf<A>(f: (a: A) => number): (acc: number, current: A) => number



export function identity<A>(a: A): A

export function flip<A, B, Out>(f: (a: A) => (b: B) => Out): (b: B) => (a: A) => Out

export function always<A>(a: A): (b: any) => A

export function not<Key extends string>(k: Key): (obj: HasKey<Key>) => boolean
export function not<A>(a: Fn1<A, any>): Fn1<A, boolean>;
export function not<A, B>(a: Fn2<A, B, any>): Fn2<A, B, boolean>;
export function not<A, B, C>(a: Fn3<A, B, C, any>): Fn3<A, B, C, boolean>;
export function not<A, B, C, D>(a: Fn4<A, B, C, D, any>): Fn4<A, B, C, D, boolean>;
export function not<A, B, C, D, E>(a: Fn5<A, B, C, D, E, any>): Fn5<A, B, C, D, E, boolean>;
export function not<Pattern>(p: Pattern): (obj: HasPattern<Pattern>) => boolean

export function and<A, Out>(a?: Fn1<A, Out>, b?: Fn1<A, Out>, c?: Fn1<A, Out>, d?: Fn1<A, Out>, e?: Fn1<A, Out>, f?: Fn1<A, Out>): Fn1<A, Out>
export function and<A, B, Out>(a?: Fn2<A, B, Out>, b?: Fn2<A, B, Out>, c?: Fn2<A, B, Out>, d?: Fn2<A, B, Out>, e?: Fn2<A, B, Out>, f?: Fn2<A, B, Out>): Fn2<A, B, Out>
export function and<A, B, C, Out>(a?: Fn3<A, B, C, Out>, b?: Fn3<A, B, C, Out>, c?: Fn3<A, B, C, Out>, d?: Fn3<A, B, C, Out>, e?: Fn3<A, B, C, Out>, f?: Fn3<A, B, C, Out>): Fn3<A, B, C, Out>
export function and<A, B, C, D, Out>(a?: Fn4<A, B, C, D, Out>, b?: Fn4<A, B, C, D, Out>, c?: Fn4<A, B, C, D, Out>, d?: Fn4<A, B, C, D, Out>, e?: Fn4<A, B, C, D, Out>, f?: Fn4<A, B, C, D, Out>): Fn4<A, B, C, D, Out>
export function and<A, B, C, D, E, Out>(a?: Fn5<A, B, C, D, E, Out>, b?: Fn5<A, B, C, D, E, Out>, c?: Fn5<A, B, C, D, E, Out>, d?: Fn5<A, B, C, D, E, Out>, e?: Fn5<A, B, C, D, E, Out>, f?: Fn5<A, B, C, D, E, Out>): Fn5<A, B, C, D, E, Out>

export function or<A, Out>(a?: Fn1<A, Out>, b?: Fn1<A, Out>, c?: Fn1<A, Out>, d?: Fn1<A, Out>, e?: Fn1<A, Out>, f?: Fn1<A, Out>): Fn1<A, Out>
export function or<A, B, Out>(a?: Fn2<A, B, Out>, b?: Fn2<A, B, Out>, c?: Fn2<A, B, Out>, d?: Fn2<A, B, Out>, e?: Fn2<A, B, Out>, f?: Fn2<A, B, Out>): Fn2<A, B, Out>
export function or<A, B, C, Out>(a?: Fn3<A, B, C, Out>, b?: Fn3<A, B, C, Out>, c?: Fn3<A, B, C, Out>, d?: Fn3<A, B, C, Out>, e?: Fn3<A, B, C, Out>, f?: Fn3<A, B, C, Out>): Fn3<A, B, C, Out>
export function or<A, B, C, D, Out>(a?: Fn4<A, B, C, D, Out>, b?: Fn4<A, B, C, D, Out>, c?: Fn4<A, B, C, D, Out>, d?: Fn4<A, B, C, D, Out>, e?: Fn4<A, B, C, D, Out>, f?: Fn4<A, B, C, D, Out>): Fn4<A, B, C, D, Out>
export function or<A, B, C, D, E, Out>(a?: Fn5<A, B, C, D, E, Out>, b?: Fn5<A, B, C, D, E, Out>, c?: Fn5<A, B, C, D, E, Out>, d?: Fn5<A, B, C, D, E, Out>, e?: Fn5<A, B, C, D, E, Out>, f?: Fn5<A, B, C, D, E, Out>): Fn5<A, B, C, D, E, Out>




export function filter<K extends string>(k: K): <F extends Collection<HasKey<K>>>(f: F) => F;
export function filter<A>(f: (a: A) => any): <F>(f: F) => F;
export function filter<Pattern>(p: Pattern): <F extends Collection<HasPattern<Pattern>>>(f: F) => F;

export function map<K extends string>(k: K): <F extends Container<HasKey<K>>>(f: F) => Functor<F, Unpack<F>, KeyAt<Unpack<F>, K>>;
export function map(i: number): <F extends Container<Indexable>>(f: F) => Functor<F, Unpack<F>, Index<Unpack<F>>>;
export function map<A, B>(f: (a: A) => B): <F extends Container<A>>(f: F) => Functor<F, A, B>;
export function map<Pattern>(p: Pattern): <A extends HasPattern<Pattern>, F extends Container<A>>(f: F) => Functor<F, A, boolean>;

export function find<Key extends string>(f: Key): <A extends HasKey<Key>>(f: Collection<A>) => (A | undefined);
export function find<A>(f: (a: A) => any): (f: Collection<A>) => (A | undefined);
export function find<Pattern>(p: Pattern): <A extends HasPattern<Pattern>>(f: Collection<A>) => (A | undefined);

export function some<Key extends string>(f: Key): (f: Collection<HasKey<Key>>) => boolean;
export function some<A>(f: (a: A) => any): (f: Collection<A>) => boolean;
export function some<Pattern>(p: Pattern): (f: Collection<HasPattern<Pattern>>) => boolean;



export function cons<A>(a: A): (as: A[]) => A[]

export function unshift<A>(a: A): (as: A[]) => A[]

export function first(s: string): string
export function first<A>(xs: A[]): A

export function rest<A>(xs: A[]): A[]

export function push<A>(a: A): (as: A[]) => A[]

export function concat<A>(as: A[]): (bs: A[]) => A[]

export function append<A>(as: A[]): (bs: A[]) => A[]

export function prepend<A>(as: A[]): (bs: A[]) => A[]



export function fill<P extends object>(pat: P): <T extends FillingPattern<P>>(value: T) => Fill<T, P>



export function has<Pattern>(p: Pattern): (obj: HasPattern<Pattern>) => boolean

export function greaterThan(a: number): (b: number) => boolean
export function greaterThan(a: string): (b: string) => boolean

export function lessThan(a: number): (b: number) => boolean
export function lessThan(a: string): (b: string) => boolean



export function toggle(b: boolean): boolean

export function returns<A>(a: A): (f: () => A) => boolean





export function add(a: number): (b: number) => number

export function sub(a: number): (b: number) => number

export function inc(a: number): number

export function dec(a: number): number



export function includes(snippet: string): (text: string) => boolean

export function includesi(snippet: string): (text: string) => boolean










export function all<A>(): Traversal<A>; // tslint:disable-line



export function matching<Key extends string>(k: Key): Traversal<HasKey<Key>>
export function matching<A>(f: (a: A) => any): Traversal<A>
export function matching<Pattern>(p: Pattern): Traversal<HasPattern<Pattern>>




export interface FindBy {
  <Key extends string>(k: Key): Lens<Collection<HasKey<Key>>, HasKey<Key>>
  <A>(f: (a: A) => any): Lens<Collection<A>, A>
  <Pattern>(p: Pattern): Lens<Collection<HasPattern<Pattern>>, HasPattern<Pattern>>

  of: <A>(pattern: any) => Lens<Collection<A>, A>
}

export const findBy: FindBy
export interface MinBy {
  <Key extends string>(k: Key): Lens<Collection<HasKey<Key>>, HasKey<Key>>
  <A>(f: (a: A) => any): Lens<Collection<A>, A>

  of: <A>(pattern: any) => Lens<Collection<A>, A>
}

export const maxBy: MinBy
export interface MaxBy {
  <Key extends string>(k: Key): Lens<Collection<HasKey<Key>>, HasKey<Key>>
  <A>(f: (a: A) => any): Lens<Collection<A>, A>

  of: <A>(pattern: any) => Lens<Collection<A>, A>
}

export const minBy: MaxBy


export function updateAll<S>(...fns: Array<(state: S) => S>): (state: S) => S



export function valueOr<T>(dflt: T): Lens<T | undefined | null, T>


export function get<K1 extends string>(k1: K1): <S extends HasKey<K1>>(s: S) => KeyAt<S, K1>

export function get(i1: number): <S extends Indexable>(s: S) => Index<S>

export function get<T1>(t1: Traversal<T1>): <S extends Collection<T1>>(s: S) => S

export function get<S1, A1>(l1: Lens<S1, A1>): (s: S1) => A1

export function get<K1 extends string, K2 extends string>(k1: K1, k2: K2): <S extends HasKey<K1, HasKey<K2>>>(s: S) => KeyAt<KeyAt<S, K1>, K2>

export function get<K1 extends string>(k1: K1, i2: number): <S extends HasKey<K1, Indexable>>(s: S) => Index<KeyAt<S, K1>>

export function get<K1 extends string, T2>(k1: K1, t2: Traversal<T2>): <S extends HasKey<K1, Collection<T2>>>(s: S) => KeyAt<S, K1>

export function get<K1 extends string, S2, A2>(k1: K1, l2: Lens<S2, A2>): (s: HasKey<K1, S2>) => A2

export function get<K2 extends string>(i1: number, k2: K2): <S extends Indexable<HasKey<K2>>>(s: S) => KeyAt<Index<S>, K2>

export function get(i1: number, i2: number): <S extends Indexable<Indexable>>(s: S) => Index<Index<S>>

export function get<T2>(i1: number, t2: Traversal<T2>): <S extends Indexable<Collection<T2>>>(s: S) => Index<S>

export function get<S2, A2>(i1: number, l2: Lens<S2, A2>): (s: Indexable<S2>) => A2

export function get<T1, K2 extends string>(t1: Traversal<T1>, k2: K2): <S extends Collection<T1 & HasKey<K2>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Unpack<S>, K2>>

export function get<T1>(t1: Traversal<T1>, i2: number): <S extends Collection<T1 & Indexable>>(s: S) => Functor<S, Unpack<S>, Index<Unpack<S>>>

export function get<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>): <S extends Collection<T1 & Collection<T2>>>(s: S) => S

export function get<T1, S2, A2>(t1: Traversal<T1>, l2: Lens<S2, A2>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A2>

export function get<S1, A1 extends HasKey<K2>, K2 extends string>(l1: Lens<S1, A1>, k2: K2): (s: S1) => KeyAt<A1, K2>

export function get<S1, A1 extends Indexable>(l1: Lens<S1, A1>, i2: number): (s: S1) => Index<A1>

export function get<S1, A1 extends Collection<T2>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>): (s: S1) => A1

export function get<S1, A1, A2>(l1: Lens<S1, A1>, l2: Lens<A1, A2>): (s: S1) => A2

export function get<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3): <S extends HasKey<K1, HasKey<K2, HasKey<K3>>>>(s: S) => KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>

export function get<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number): <S extends HasKey<K1, HasKey<K2, Indexable>>>(s: S) => Index<KeyAt<KeyAt<S, K1>, K2>>

export function get<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>): <S extends HasKey<K1, HasKey<K2, Collection<T3>>>>(s: S) => KeyAt<KeyAt<S, K1>, K2>

export function get<K1 extends string, K2 extends string, S3, A3>(k1: K1, k2: K2, l3: Lens<S3, A3>): (s: HasKey<K1, HasKey<K2, S3>>) => A3

export function get<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3): <S extends HasKey<K1, Indexable<HasKey<K3>>>>(s: S) => KeyAt<Index<KeyAt<S, K1>>, K3>

export function get<K1 extends string>(k1: K1, i2: number, i3: number): <S extends HasKey<K1, Indexable<Indexable>>>(s: S) => Index<Index<KeyAt<S, K1>>>

export function get<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>): <S extends HasKey<K1, Indexable<Collection<T3>>>>(s: S) => Index<KeyAt<S, K1>>

export function get<K1 extends string, S3, A3>(k1: K1, i2: number, l3: Lens<S3, A3>): (s: HasKey<K1, Indexable<S3>>) => A3

export function get<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3): <S extends HasKey<K1, Collection<T2 & HasKey<K3>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Unpack<KeyAt<S, K1>>, K3>>

export function get<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number): <S extends HasKey<K1, Collection<T2 & Indexable>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Unpack<KeyAt<S, K1>>>>

export function get<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>): <S extends HasKey<K1, Collection<T2 & Collection<T3>>>>(s: S) => KeyAt<S, K1>

export function get<K1 extends string, T2, S3, A3>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A3>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3): (s: HasKey<K1, S2>) => KeyAt<A2, K3>

export function get<K1 extends string, S2, A2 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number): (s: HasKey<K1, S2>) => Index<A2>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>): (s: HasKey<K1, S2>) => A2

export function get<K1 extends string, S2, A2, A3>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (s: HasKey<K1, S2>) => A3

export function get<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3): <S extends Indexable<HasKey<K2, HasKey<K3>>>>(s: S) => KeyAt<KeyAt<Index<S>, K2>, K3>

export function get<K2 extends string>(i1: number, k2: K2, i3: number): <S extends Indexable<HasKey<K2, Indexable>>>(s: S) => Index<KeyAt<Index<S>, K2>>

export function get<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>): <S extends Indexable<HasKey<K2, Collection<T3>>>>(s: S) => KeyAt<Index<S>, K2>

export function get<K2 extends string, S3, A3>(i1: number, k2: K2, l3: Lens<S3, A3>): (s: Indexable<HasKey<K2, S3>>) => A3

export function get<K3 extends string>(i1: number, i2: number, k3: K3): <S extends Indexable<Indexable<HasKey<K3>>>>(s: S) => KeyAt<Index<Index<S>>, K3>

export function get(i1: number, i2: number, i3: number): <S extends Indexable<Indexable<Indexable>>>(s: S) => Index<Index<Index<S>>>

export function get<T3>(i1: number, i2: number, t3: Traversal<T3>): <S extends Indexable<Indexable<Collection<T3>>>>(s: S) => Index<Index<S>>

export function get<S3, A3>(i1: number, i2: number, l3: Lens<S3, A3>): (s: Indexable<Indexable<S3>>) => A3

export function get<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3): <S extends Indexable<Collection<T2 & HasKey<K3>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Unpack<Index<S>>, K3>>

export function get<T2>(i1: number, t2: Traversal<T2>, i3: number): <S extends Indexable<Collection<T2 & Indexable>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Unpack<Index<S>>>>

export function get<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>): <S extends Indexable<Collection<T2 & Collection<T3>>>>(s: S) => Index<S>

export function get<T2, S3, A3>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A3>

export function get<S2, A2 extends HasKey<K3>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3): (s: Indexable<S2>) => KeyAt<A2, K3>

export function get<S2, A2 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number): (s: Indexable<S2>) => Index<A2>

export function get<S2, A2 extends Collection<T3>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>): (s: Indexable<S2>) => A2

export function get<S2, A2, A3>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (s: Indexable<S2>) => A3

export function get<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3): <S extends Collection<T1 & HasKey<K2, HasKey<K3>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Unpack<S>, K2>, K3>>

export function get<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number): <S extends Collection<T1 & HasKey<K2, Indexable>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Unpack<S>, K2>>>

export function get<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>): <S extends Collection<T1 & HasKey<K2, Collection<T3>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Unpack<S>, K2>>

export function get<T1, K2 extends string, S3, A3>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A3>

export function get<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3): <S extends Collection<T1 & Indexable<HasKey<K3>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Unpack<S>>, K3>>

export function get<T1>(t1: Traversal<T1>, i2: number, i3: number): <S extends Collection<T1 & Indexable<Indexable>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Unpack<S>>>>

export function get<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>): <S extends Collection<T1 & Indexable<Collection<T3>>>>(s: S) => Functor<S, Unpack<S>, Index<Unpack<S>>>

export function get<T1, S3, A3>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A3>

export function get<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3): <S extends Collection<T1 & Collection<T2 & HasKey<K3>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Unpack<Unpack<S>>, K3>>>

export function get<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number): <S extends Collection<T1 & Collection<T2 & Indexable>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Unpack<Unpack<S>>>>>

export function get<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>): <S extends Collection<T1 & Collection<T2 & Collection<T3>>>>(s: S) => S

export function get<T1, T2, S3, A3>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A3>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A2, K3>>

export function get<T1, S2, A2 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A2>>

export function get<T1, S2, A2 extends Collection<T3>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A2>

export function get<T1, S2, A2, A3>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A3>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3): (s: S1) => KeyAt<KeyAt<A1, K2>, K3>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number): (s: S1) => Index<KeyAt<A1, K2>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>): (s: S1) => KeyAt<A1, K2>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>): (s: S1) => A3

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3): (s: S1) => KeyAt<Index<A1>, K3>

export function get<S1, A1 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, i3: number): (s: S1) => Index<Index<A1>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>): (s: S1) => Index<A1>

export function get<S1, A1 extends Indexable, A3>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>): (s: S1) => A3

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3): (s: S1) => Functor<A1, T2, KeyAt<T2, K3>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number): (s: S1) => Functor<A1, T2, Index<T2>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>): (s: S1) => A1

export function get<S1, A1 extends Collection<T2>, T2, A3>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>): (s: S1) => Functor<A1, T2, A3>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3): (s: S1) => KeyAt<A2, K3>

export function get<S1, A1, A2 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number): (s: S1) => Index<A2>

export function get<S1, A1, A2 extends Collection<T3>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>): (s: S1) => A2

export function get<S1, A1, A2, A3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>): (s: S1) => A3

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>

export function get<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4>>>>>(s: S) => KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => A4

export function get<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>

export function get<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable>>>>(s: S) => Index<Index<KeyAt<KeyAt<S, K1>, K2>>>

export function get<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4>>>>>(s: S) => Index<KeyAt<KeyAt<S, K1>, K2>>

export function get<K1 extends string, K2 extends string, S4, A4>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => A4

export function get<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>

export function get<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>

export function get<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4>>>>>(s: S) => KeyAt<KeyAt<S, K1>, K2>

export function get<K1 extends string, K2 extends string, T3, S4, A4>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A4>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<A3, K4>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<A3>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (s: HasKey<K1, HasKey<K2, S3>>) => A3

export function get<K1 extends string, K2 extends string, S3, A3, A4>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (s: HasKey<K1, HasKey<K2, S3>>) => A4

export function get<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>

export function get<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable>>>>(s: S) => Index<KeyAt<Index<KeyAt<S, K1>>, K3>>

export function get<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4>>>>>(s: S) => KeyAt<Index<KeyAt<S, K1>>, K3>

export function get<K1 extends string, K3 extends string, S4, A4>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => A4

export function get<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4>>>>>(s: S) => KeyAt<Index<Index<KeyAt<S, K1>>>, K4>

export function get<K1 extends string>(k1: K1, i2: number, i3: number, i4: number): <S extends HasKey<K1, Indexable<Indexable<Indexable>>>>(s: S) => Index<Index<Index<KeyAt<S, K1>>>>

export function get<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4>>>>>(s: S) => Index<Index<KeyAt<S, K1>>>

export function get<K1 extends string, S4, A4>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => A4

export function get<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>

export function get<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<Unpack<Index<KeyAt<S, K1>>>>>

export function get<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4>>>>>(s: S) => Index<KeyAt<S, K1>>

export function get<K1 extends string, T3, S4, A4>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A4>

export function get<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4): (s: HasKey<K1, Indexable<S3>>) => KeyAt<A3, K4>

export function get<K1 extends string, S3, A3 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number): (s: HasKey<K1, Indexable<S3>>) => Index<A3>

export function get<K1 extends string, S3, A3 extends Collection<T4>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (s: HasKey<K1, Indexable<S3>>) => A3

export function get<K1 extends string, S3, A3, A4>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (s: HasKey<K1, Indexable<S3>>) => A4

export function get<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>

export function get<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>

export function get<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Unpack<KeyAt<S, K1>>, K3>>

export function get<K1 extends string, T2, K3 extends string, S4, A4>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A4>

export function get<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>

export function get<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<Unpack<KeyAt<S, K1>>>>>

export function get<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Unpack<KeyAt<S, K1>>>>

export function get<K1 extends string, T2, S4, A4>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A4>

export function get<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>>

export function get<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<Unpack<Unpack<KeyAt<S, K1>>>>>>

export function get<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4>>>>>(s: S) => KeyAt<S, K1>

export function get<K1 extends string, T2, T3, S4, A4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A4>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A3, K4>>

export function get<K1 extends string, T2, S3, A3 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A3>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A3>

export function get<K1 extends string, T2, S3, A3, A4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A4>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4): (s: HasKey<K1, S2>) => KeyAt<KeyAt<A2, K3>, K4>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number): (s: HasKey<K1, S2>) => Index<KeyAt<A2, K3>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>): (s: HasKey<K1, S2>) => KeyAt<A2, K3>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (s: HasKey<K1, S2>) => A4

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4): (s: HasKey<K1, S2>) => KeyAt<Index<A2>, K4>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number): (s: HasKey<K1, S2>) => Index<Index<A2>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (s: HasKey<K1, S2>) => Index<A2>

export function get<K1 extends string, S2, A2 extends Indexable, A4>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (s: HasKey<K1, S2>) => A4

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<T3, K4>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<T3>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (s: HasKey<K1, S2>) => A2

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (s: HasKey<K1, S2>) => Functor<A2, T3, A4>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (s: HasKey<K1, S2>) => KeyAt<A3, K4>

export function get<K1 extends string, S2, A2, A3 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (s: HasKey<K1, S2>) => Index<A3>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (s: HasKey<K1, S2>) => A3

export function get<K1 extends string, S2, A2, A3, A4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (s: HasKey<K1, S2>) => A4

export function get<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>

export function get<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable>>>>(s: S) => Index<KeyAt<KeyAt<Index<S>, K2>, K3>>

export function get<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4>>>>>(s: S) => KeyAt<KeyAt<Index<S>, K2>, K3>

export function get<K2 extends string, K3 extends string, S4, A4>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => A4

export function get<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4>>>>>(s: S) => KeyAt<Index<KeyAt<Index<S>, K2>>, K4>

export function get<K2 extends string>(i1: number, k2: K2, i3: number, i4: number): <S extends Indexable<HasKey<K2, Indexable<Indexable>>>>(s: S) => Index<Index<KeyAt<Index<S>, K2>>>

export function get<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4>>>>>(s: S) => Index<KeyAt<Index<S>, K2>>

export function get<K2 extends string, S4, A4>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => A4

export function get<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>

export function get<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<Unpack<KeyAt<Index<S>, K2>>>>

export function get<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4>>>>>(s: S) => KeyAt<Index<S>, K2>

export function get<K2 extends string, T3, S4, A4>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A4>

export function get<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4): (s: Indexable<HasKey<K2, S3>>) => KeyAt<A3, K4>

export function get<K2 extends string, S3, A3 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number): (s: Indexable<HasKey<K2, S3>>) => Index<A3>

export function get<K2 extends string, S3, A3 extends Collection<T4>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (s: Indexable<HasKey<K2, S3>>) => A3

export function get<K2 extends string, S3, A3, A4>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (s: Indexable<HasKey<K2, S3>>) => A4

export function get<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4>>>>>(s: S) => KeyAt<KeyAt<Index<Index<S>>, K3>, K4>

export function get<K3 extends string>(i1: number, i2: number, k3: K3, i4: number): <S extends Indexable<Indexable<HasKey<K3, Indexable>>>>(s: S) => Index<KeyAt<Index<Index<S>>, K3>>

export function get<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4>>>>>(s: S) => KeyAt<Index<Index<S>>, K3>

export function get<K3 extends string, S4, A4>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => A4

export function get<K4 extends string>(i1: number, i2: number, i3: number, k4: K4): <S extends Indexable<Indexable<Indexable<HasKey<K4>>>>>(s: S) => KeyAt<Index<Index<Index<S>>>, K4>

export function get(i1: number, i2: number, i3: number, i4: number): <S extends Indexable<Indexable<Indexable<Indexable>>>>(s: S) => Index<Index<Index<Index<S>>>>

export function get<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>): <S extends Indexable<Indexable<Indexable<Collection<T4>>>>>(s: S) => Index<Index<Index<S>>>

export function get<S4, A4>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>): (s: Indexable<Indexable<Indexable<S4>>>) => A4

export function get<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<Unpack<Index<Index<S>>>, K4>>

export function get<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number): <S extends Indexable<Indexable<Collection<T3 & Indexable>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<Unpack<Index<Index<S>>>>>

export function get<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4>>>>>(s: S) => Index<Index<S>>

export function get<T3, S4, A4>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A4>

export function get<S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4): (s: Indexable<Indexable<S3>>) => KeyAt<A3, K4>

export function get<S3, A3 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number): (s: Indexable<Indexable<S3>>) => Index<A3>

export function get<S3, A3 extends Collection<T4>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (s: Indexable<Indexable<S3>>) => A3

export function get<S3, A3, A4>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (s: Indexable<Indexable<S3>>) => A4

export function get<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>

export function get<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<Unpack<Index<S>>, K3>>>

export function get<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Unpack<Index<S>>, K3>>

export function get<T2, K3 extends string, S4, A4>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A4>

export function get<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<Unpack<Index<S>>>, K4>>

export function get<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number): <S extends Indexable<Collection<T2 & Indexable<Indexable>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<Unpack<Index<S>>>>>

export function get<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Unpack<Index<S>>>>

export function get<T2, S4, A4>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A4>

export function get<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<Unpack<Unpack<Index<S>>>, K4>>>

export function get<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<Unpack<Unpack<Index<S>>>>>>

export function get<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4>>>>>(s: S) => Index<S>

export function get<T2, T3, S4, A4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A4>>

export function get<T2, S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A3, K4>>

export function get<T2, S3, A3 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A3>>

export function get<T2, S3, A3 extends Collection<T4>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A3>

export function get<T2, S3, A3, A4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A4>

export function get<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4): (s: Indexable<S2>) => KeyAt<KeyAt<A2, K3>, K4>

export function get<S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number): (s: Indexable<S2>) => Index<KeyAt<A2, K3>>

export function get<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>): (s: Indexable<S2>) => KeyAt<A2, K3>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (s: Indexable<S2>) => A4

export function get<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4): (s: Indexable<S2>) => KeyAt<Index<A2>, K4>

export function get<S2, A2 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number): (s: Indexable<S2>) => Index<Index<A2>>

export function get<S2, A2 extends Indexable<Collection<T4>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (s: Indexable<S2>) => Index<A2>

export function get<S2, A2 extends Indexable, A4>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (s: Indexable<S2>) => A4

export function get<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<T3, K4>>

export function get<S2, A2 extends Collection<T3 & Indexable>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (s: Indexable<S2>) => Functor<A2, T3, Index<T3>>

export function get<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (s: Indexable<S2>) => A2

export function get<S2, A2 extends Collection<T3>, T3, A4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (s: Indexable<S2>) => Functor<A2, T3, A4>

export function get<S2, A2, A3 extends HasKey<K4>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (s: Indexable<S2>) => KeyAt<A3, K4>

export function get<S2, A2, A3 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (s: Indexable<S2>) => Index<A3>

export function get<S2, A2, A3 extends Collection<T4>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (s: Indexable<S2>) => A3

export function get<S2, A2, A3, A4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (s: Indexable<S2>) => A4

export function get<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>

export function get<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>

export function get<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Unpack<S>, K2>, K3>>

export function get<T1, K2 extends string, K3 extends string, S4, A4>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>

export function get<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<Unpack<S>, K2>>>>

export function get<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Unpack<S>, K2>>>

export function get<T1, K2 extends string, S4, A4>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>>

export function get<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<Unpack<KeyAt<Unpack<S>, K2>>>>>

export function get<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Unpack<S>, K2>>

export function get<T1, K2 extends string, T3, S4, A4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack